在一般程序开发中可以使用synchronized同步多线程

标签：线程同步   关系   访问   并发   因此   存在   new t   set   catch   

如果程序不是高并发的场景，则使用synchronized线程同步足够处理。

synchronized关键字解释（synchronized(this)同步代码块也可以被替换为同步对象方法或者同步类方法，本质是一样的）：

1. 多个线程，访问同一个对象中的synchronized(this)同步代码块时，每一个线程需要串行得到执行。其他线程必须等待当前线程执行完以后才能执行。

2. 当一个线程对象一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。

3. 当一个线程访问对象的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

4. 当一个线程访问对象的一个synchronized(this)同步代码块时，它就获得了这个对象的锁。其它线程对该对象所有同步代码部分的访问都被暂时阻塞。

总之，synchronized是针对某个对象或者类对象进行锁，同步代码或者方法只是表象，实际上是锁的对象，多个线程只要拥有相同对象，则对该对象的任何使用都将受到锁的约束。如果拥有不同对象，则不同对象彼此间正常是没有锁的约束关系的，因此也就不存在多线程之间的同步了。

如下toy是对toy的对象进行同步。

public class toy {
    private int number;
    public toy(){
        number = 100;
    }
    //一个时刻，只能一个boy拿到这个toy
    synchronized public void getToy()
    {

        number--;
        System.out.println(Thread.currentThread().getName() + " toy‘s total number reduced one! now : " + number);

    }
    //一个boy在玩toy，另外一个boy虽然不能玩，但是能看嘛
    public void showHello()
    {
        System.out.println(Thread.currentThread().getName()+"hello begin");
        try{
            int i = (int) (Math.random()*10000);
        System.out.println(i+"seconds");

        Thread.sleep(i);
        }
        catch(Exception e)
        {

        }
        System.out.println(Thread.currentThread().getName()+"hello end");

    }
    //一个时刻，只能一个boy对这个玩具进行paint
    synchronized public void paint()
    {
        System.out.println("thread:"+Thread.currentThread().getName() + ":paint begin");
        try{
            int i = (int) (Math.random()*10000);
        System.out.println(i+"seconds");

        Thread.sleep(i);
        }
        catch(Exception e)
        {

        }
        System.out.println("thread:"+Thread.currentThread().getName()+":paint");
        System.out.println("thread:"+Thread.currentThread().getName() + ":paint end");
    }
        //一个时刻，只能一个boy对这个玩具进行write
     synchronized public void write()
    {
        System.out.println("thread:"+Thread.currentThread().getName() + ":write begin");
        try{
            int i = (int) (Math.random()*10000);
        System.out.println(i+"seconds");
        Thread.sleep(i);
        }
        catch(Exception e)
        {

        }
        System.out.println("thread:"+Thread.currentThread().getName()+":write");
        System.out.println("thread:"+Thread.currentThread().getName() + ":write end");
    }
}

创建一个boy类，来使用toy

public class boy extends Thread{
    private toy mytoy;
    public boy(toy t)
    {
        mytoy = t;
    }
    public void run()
    {
        super.run();

        mytoy.write();
        mytoy.showHello();
        mytoy.paint();

    }

}

测试，有两个boy，都要玩同一个toy，此时就会出现同步情况，必须一个玩好了，另一个才能玩。

public class Test {

    public static void main(String[] args) {
        toy mytoy = new toy();
        boy myboy = new boy(mytoy);
        boy youboy = new boy(mytoy);
        myboy.setName("myboy");
        youboy.setName("youboy");
        myboy.start();
        youboy.start();
    }

}

在一般程序开发中可以使用synchronized同步多线程

标签：线程同步   关系   访问   并发   因此   存在   new t   set   catch   

原文地址：http://blog.51cto.com/ggwhsd/2342834