Java多线程同步Synchronized使用并详细分析与实例 【huiqinbo转于网络并总结】

一.Synchronized基本知识：

 

在Java应用中，使用多线程进行工作的需要是越来越多，使用多线程进行工作，大大的提高了系统的工作效率，然而因此而产生的问题也是层出不穷，而且因为多线程而产生的问题跟踪是一个难题。

同步的概念：
    同步分为 方法同步 和 同步块  两种方式。

使用同步的原因
   1. 在系统中对访类要使用多线程进行访问；
   2. 在该类中有 类变量， 或者是 在类的方法中有访问 公共资源（如一个外部文件的读写）。

 

同步所锁定的内容是什么？

    

 

下例中分情况的列举各种情况下的同步效果

 

1. Synchronized 加在方法上， （方法同步）

 

public  synchronized void function1(){ ……}

public  void function2(){

         synchronized （this）{……}

    ……}

这两种写法的效果是一样的，锁定的都是类实例对象。

如果有一个 类实例对象：   inst = new ClassSynInst（），

另外有两个线程： threada，threadb，都调用了inst 对象，那么，在同一时间，如果 threada调用了inst.function1()，则threadb在该时间内不能访问inst.function1() 和 inst.function2(); 因为threada把inst这个对象的锁使用了，所以无法分给其它线程使用

但是，如果threada调用 inst1.function1(), threadb调用 inst2.function1(), 则可以同时进行，因为它们调用的是不同的ClassSynInst类对象实例。

 

钦波总结：无论你将Synchronized加在方法前还是加在一个变量前，其锁定的都是一个 类对象。 每一个对象都只有一个锁与之相关联。

 

 

 

2. Synchronized 加在变量上， （同步块）

 Object a = new Object（）；

 Object b = new Object（）；

 

 

public  void function1(){

         synchronized （a）{……}

    ……}

public  void function2(){

         synchronized （b）{……}

    ……}

 

这种情况下，是实现代码块锁定，锁定的对象是 变量 a 或 b； （注意，a 、b 都是非static 的）

 

如果有一个 类实例对象：   inst = new ClassSynInst（），

另外有两个线程： threada，threadb，都调用了inst 对象，那么，在同一时间，如果 threada调用了inst.function1()，则threadb在该时间内可以访问inst.function2(); 但不能访问  inst.function1() 的同步块， 因为a被 threada锁定了。

 

钦波总结：你将Synchronized锁在代码块中，其锁定的不是一个 类对象，而锁定的是变量a或b。 

 

 

3. Synchronized 锁定的是 类变量 ，即static 变量

 

class Test{ 
 static Object o= new Object(); 

public static synchronized void f1(){ ……} 

public static void f2(){ 
synchronized(Test.class){ ……} 
} 

public static void f3(){ 
try { 
synchronized (Class.forName("Test")) { ……} 
} 
catch (ClassNotFoundException ex) { 
} 
} 

public static void f4(){ 
synchronized(o){ ……} 
} 
} 

 

钦波总结：以上4个方法中实现的效果都是一样的，其锁定的对象都是类Test，而不是类实例对象 ，即在多线程中，其共享的资源是属于类的，而不是属于类对象的。

在这种情况下，如果threada 访问了这4个方法中的任何一个， 在同一时间内其它的线程都不能访问 这4个方法。

 

 

4. 类的方法中访问了多线程共同的资源, 且该资源是可变的，这种情况下也是需要进行同步的

例：

class test {

    static String path = “ file path”；    

    public void  readConfiFile(){

          synchronized （path）{

              // 读取该path指定的文件。

         }

 

   }

 

     public void  writeConfiFile(){

        synchronized （path）{

              // 写信息到该path指定的文件。

         }

   }

 

}

 

这种情况下，必须锁定为 类变量，而不能进行锁定类实例对象，因为这是变象的一种类资源共享，而不是类实例对象资源共享。

 

 

线程，成也其，败也其，用好了可以提升性能，用不好则会使系统后患无穷。

 

PS： 进行线程同步需要很大的系统开销， 所以，在使用时，如果不是必须的，则尽量不使用同步功能。

 

 

 

二.Synchronized实用例子：

 

先看一个例子：

//模仿火车售票系统，假设有4个售票点同时售票，我们可以把四个售票点定义为四个独立线程

class Test
{
 public static void main(String[] args)
 {
  TestThread tt=new TestThread();
  new Thread(tt).start();        //每一个售票点定义为一个独立的线程，共同卖出所有的票
  new Thread(tt).start();
  new Thread(tt).start();
  new Thread(tt).start();
 }
}

class TestThread implements Runnable
{
 int ticket=10;                 //票数定义
 public void run()
 {
  while(ticket>0)
  {

     System.out.println(Thread.currentThread().getName()+":ticket "+ticket+"is saling");

     ticket--;

  }

 }

}

运行结果为：

Thread-0:ticket 10is saling
Thread-0:ticket 9is saling
Thread-0:ticket 8is saling
Thread-0:ticket 7is saling
Thread-0:ticket 6is saling
Thread-0:ticket 5is saling
Thread-0:ticket 4is saling
Thread-0:ticket 3is saling
Thread-1:ticket 3is saling
Thread-2:ticket 3is saling
Thread-3:ticket 3is saling
Thread-1:ticket 2is saling
Thread-2:ticket 1is saling

我们可以看出来票３倍卖出了４次，很明显不正确，我们仔细观察程序，可以发现问题出在

while(ticket>0)
  {
   System.out.println(Thread.currentThread().getName()+":ticket "+ticket+"is saling");

   ticket--;

  }　　

的执行当中，当线程０（模拟售票点１）执行System.out.println(Thread.currentThread().getName()+":ticket "+ticket+"is saling");语句时（模拟售票点１卖出票３），这时，CPU切换到了线程１（售票点２）

而这时，售票点０卖出了票３，但是在剩余的票中没有及时将票３除去（即执行ticket--;语句），所以此时在线程１处，并不知道票３已经卖出，所以它又把票３卖出，同理，售票点２和３也重复地卖了票３，原因是我们无法确定CPU无法进行线程切换，如果我们可以把一段要执行的语句放到一个无法分开的块中，使CPU没有执行完这个块时无法去执行其他的块，我们就可以正确实现上述售票模拟了，这就是synchronized关键字的作用！！

 

我们把上述实现改动一下，并加入synchronized代码块

 

class Test
{
 public static void main(String[] args)
 {
  TestThread tt=new TestThread();
  new Thread(tt).start();
  new Thread(tt).start();
  new Thread(tt).start();
  new Thread(tt).start();
 }
}

class TestThread implements Runnable
{
 int ticket=10;
 String str=new String(" ");
 public void run()
 {
  while(true)
  { 
   synchronized(str)                    //synchronized 代码块
   {
    if(ticket>0)
    {
     System.out.println(Thread.currentThread().getName()+":ticket "+ticket--+"is saling");
    }
   }
  }
 }
};

 

运行一下，结果为：

Thread-0:ticket 10is saling
Thread-0:ticket 9is saling
Thread-0:ticket 8is saling
Thread-0:ticket 7is saling
Thread-0:ticket 6is saling
Thread-0:ticket 5is saling
Thread-0:ticket 4is saling
Thread-0:ticket 3is saling
Thread-1:ticket 2is saling
Thread-2:ticket 1is saling

 

结果正确

 

我们再改动一下我们的程序：

class Test
{
 public static void main(String[] args)
 {
  TestThread tt=new TestThread();
  new Thread(tt).start();
  new Thread(tt).start();
  new Thread(tt).start();
  new Thread(tt).start();
 }
}

class TestThread implements Runnable
{
 int ticket=10;
 String str=new String(" ");
 public void run()
 {
  while(true)
  {
   sale();
  }
 }
 public synchronized void sale()      //synchronized方法
 {
  if(ticket > 0)
   System.out.println(Thread.currentThread().getName()+":ticket "+ticket--+"is saling");

 }
};

运行结果为：

Thread-0:ticket 10is saling
Thread-0:ticket 9is saling
Thread-0:ticket 8is saling
Thread-0:ticket 7is saling
Thread-0:ticket 6is saling
Thread-0:ticket 5is saling
Thread-0:ticket 4is saling
Thread-0:ticket 3is saling
Thread-1:ticket 2is saling
Thread-2:ticket 1is saling

结果也正确！

 

由此我们给出synchronized关键字在多线程中的作用：

两种用法：synchronized 方法和 synchronized 块。
1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如上述例子所述。
synchronized 方法控制对类成员变量的访问：每个类实例对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例对象的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例对象，其所有声明为 synchronized 的成员方法中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对象对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。
在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。
synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用（如上述例子中的sale()方法，在run()方法中来调用sale()方法）来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。
2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：
synchronized(syncObject) {
//允许访问控制的代码
}
synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类，上述例子中我们定义了一个String类的对象）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

对synchronized(this)的一些理解

 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

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

五、以上规则对其它对象锁同样适用.

 

更多交流、更多了解：

QQ:444084929  个人主页：http://www.huiqinbo.com