Java高级之线程(二)

这个关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码，没错这就是我们今天要重点说的synchronized

首先synchronized，是一种同步锁。它修饰的对象有以下几种：

(1). 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
(2). 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
(3). 修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
(4). 修饰一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

(1)

//一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞
package ths;

public class Thread1 implements Runnable { 
     public void run() { 
          synchronized(this) { 
               for (int i = 0; i < 5; i++) { 
                    System.out.println(Thread.currentThread().getName()+"" + i); 
               } 
          } 
     } 
     public static void main(String[] args) { 
          Thread1 t1 = new Thread1(); 
          Thread thread1 = new Thread(t1, "A"); 
          Thread thread2= new Thread(t1, "B"); 
          thread1.start(); 
          thread2.start(); 
     }
}

运行结果（随机）:
A0
A1
A2
A3
A4
B0
B1
B2
B3
B4

当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时，在同一时刻只能有一个线程得到执行，另一个线程受阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块。thread1和thread2是互斥的，因为当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象。
如果我们再把Thread1的调用稍微改一下：

package ths;

public class Thread1 implements Runnable { 
     public void run() { 
          synchronized(this) { 
               for (int i = 0; i < 5; i++) { 
                    System.out.println(Thread.currentThread().getName()+"" + i); 
               } 
          } 
     } 
     public static void main(String[] args) { 
          Thread1 t1 = new Thread1(); 
          Thread1 t2 = new Thread1(); 
          Thread thread1 = new Thread(t1, "A"); 
          Thread thread2= new Thread(t2, "B"); 
          thread1.start(); 
          thread2.start(); 
     }
}

运行结果:
A0
B0
A1
A2
B1
B2
A3
A4
B3
B4

不是说一个线程执行synchronized代码块时其它的线程受阻塞吗？为什么上面的例子中thread1和thread2同时在执行。这是因为synchronized只锁定对象，每个对象只有一个锁（lock）与之相关联。

这时创建了两个Thread1的对象t1和t2，线程thread1执行的是t1对象中的synchronized代码(run)，而线程thread2执行的是t2对象中的synchronized代码(run)；我们知道synchronized锁定的是对象，这时会有两把锁分别锁定t1对象和t2对象，而这两把锁是互不干扰的，不形成互斥，所以两个线程可以同时执行。

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

class Counter implements Runnable{
   private int count;

   public Counter() {
      count = 0;
   }

   public void countAdd() {
      synchronized(this) {
         for (int i = 0; i < 5; i ++) {
            try {
               System.out.println(Thread.currentThread().getName() + ":" + (count++));
               Thread.sleep(100);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      }
   }

   //非synchronized代码块，未对count进行读写操作，所以可以不用synchronized
   public void printCount() {
      for (int i = 0; i < 5; i ++) {
         try {
            System.out.println(Thread.currentThread().getName() + " count:" + count);
            Thread.sleep(100);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }

   public void run() {
      String threadName = Thread.currentThread().getName();
      if (threadName.equals("A")) {
         countAdd();
      } else if (threadName.equals("B")) {
         printCount();
      }
   }
}

public static void main(String[] args) { 
     Counter counter = new Counter();
    Thread thread1 = new Thread(counter, "A");
    Thread thread2 = new Thread(counter, "B");
    thread1.start();
    thread2.start();
}

运行结果:
A:0
B count:1
A:1
B count:2
A:2
B count:3
A:3
B count:4
A:4
B count:5

上面代码中countAdd是一个synchronized的，printCount是非synchronized的。从上面的结果中可以看出一个线程访问一个对象的synchronized代码块时，别的线程可以访问该对象的非synchronized代码块而不受阻塞。

(3).把synchronized当作函数修饰符时

Public synchronized void methodAAA()

{

//….

}

这也就是同步方法，那这时synchronized锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中

执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了
synchronized关键字的方法。

上边的代码等同于如下代码：

public void methodAAA()

{

synchronized (this)      // (1)

{

       //…..

}

}

在进一步阐述之前，我们需要明确几点：

A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其

他线程的对象访问。

B．每个对象只有一个锁（lock）与之相关联。

C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。