Java多线程synchronized同步

非线程安全问题

“非线程安全”问题存在于“实例变量”中，如果是方法内部的私有变量，则不存在“非线程问题”。也即是说，方法中的变量永远是线程安全的。

如果多个线程共同访问1个对象中的实例变量，则可能线程不安全。下面以实例说明

 public class HasSelfNum {
     private int num = 0;
     public void add(String name) {
         try {
             if (name.equals("a")) {
                 num = 100;
                 System.out.println("a over");
                 Thread.sleep(1000);
             } else {
                 num = 200;
                 System.out.println("b over");
             }
             System.out.println(name+" "+num);
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }
 }

 public class ThreadA extends Thread{
     private HasSelfNum hasSelfNum;

     public ThreadA(HasSelfNum hasSelfNum) {
         this.hasSelfNum = hasSelfNum;
     }

     @Override
     public void run() {
         super.run();
         hasSelfNum.add("a");
     }
 }

 public class ThreadB extends Thread{
     private HasSelfNum hasSelfNum;

     public ThreadB(HasSelfNum hasSelfNum) {
         this.hasSelfNum = hasSelfNum;
     }

     @Override
     public void run() {
         super.run();
         hasSelfNum.add("b");
     }
 }

 public class Main {
     public static void main(String[] args) {
         HasSelfNum hasSelfNum = new HasSelfNum();
         ThreadA threadA = new ThreadA(hasSelfNum);
         ThreadB threadB = new ThreadB(hasSelfNum);

         threadA.start();
         threadB.start();
     }
 }

Result

 a over
 b over
 b 200
 a 200

非线程安全！

如何处理？

在add方法上加上关键字 synchronized

synchronized public void add(String name)

Result

 a over
 a 100
 b over
 b 200

线程安全，同步访问add()方法

如果是多个对象的情况？

将上面的Main.java进行修改

 public class Main {
     public static void main(String[] args) {
         HasSelfNum hasSelfNum = new HasSelfNum();
         HasSelfNum hasSelfNum2 = new HasSelfNum(); //两个对象

         ThreadA threadA = new ThreadA(hasSelfNum);
         ThreadB threadB = new ThreadB(hasSelfNum2);

         threadA.start();
         threadB.start();
     }
 }

Result

 a over
 b over
 b 200
 a 100

两个线程分别访问同一个类的不同实例的相同同步方法，产生了两个锁，运行的结果是异步的。

由此可以看出，关键字synchronized取得的锁是对象锁

若类中既有synchronized类型方法又有非synchronized类型方法

 public class MyObject {
     synchronized public void methodA(){
         try {
             System.out.println(Thread.currentThread().getName()+" begin");
             Thread.sleep(1000);
             System.out.println(Thread.currentThread().getName()+" end");
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }

     public void methodB(){
         try {
             System.out.println(Thread.currentThread().getName()+" begin");
             Thread.sleep(1000);
             System.out.println(Thread.currentThread().getName()+" end");
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }

 }

 public class ThreadA extends Thread{
     MyObject myObject;
     public ThreadA(MyObject    myObject) {
         this.myObject = myObject;
     }

     @Override
     public void run() {
         super.run();
         myObject.methodA();
     }
 }

 public class ThreadB extends Thread{
     MyObject myObject;
     public ThreadB(MyObject    myObject) {
         this.myObject = myObject;
     }

     @Override
     public void run() {
         super.run();
         myObject.methodB();
     }
 }

 public class Main {
     public static void main(String[] args) {
         MyObject myObject = new MyObject();

         ThreadA threadA = new ThreadA(myObject);
         ThreadB threadB = new ThreadB(myObject);
         threadA.setName("A");
         threadB.setName("B");

         threadA.start();
         threadB.start();
     }
 }

Result

 A begin
 B begin
 B end
 A end

线程A持有myObject对象锁，但线程B仍可以异步调用非synchronized类型方法

当在methodB方法前也加上synchronized关键字时

Result

 A begin
 A end
 B begin
 B end

线程A、B以同步的方式执行对象中的两方法

synchronized同步代码块

当synchronized修饰的方法里有个耗时很长的代码时，效率是很低的。同步代码块分为：

1.synchronized(this)

在方法中不在同步代码块中的代码异步执行，而在其中的代码同步执行

同个对象中的synchronized(this)使用的对象监视器是同一个，也就是说，当一个线程访问某个synchronized(this)代码块里面的方法时，其他线程访问其他synchronized(this)块里面的方法是会被阻塞的。另外synchronized(this)使用的监视器和syncheronized 修饰方法一致是当前对象，也会阻塞synchronized修饰的方法。

2.synchronized(obj) 非this

多个线程同时访问时只能阻塞synchronized(obj)的代码块。

同时如果锁是同一个myObject对象，还是会阻塞的

 public class MyObject {
     synchronized public void methodA() {
         try {
             System.out.println(Thread.currentThread().getName() + " begin");
             Thread.sleep(1000);
             System.out.println(Thread.currentThread().getName() + " end");
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }
     public void methodB(MyObject myObject) {
         synchronized (myObject) {
             try {
                 System.out.println(Thread.currentThread().getName() + " begin");
                 Thread.sleep(1000);
                 System.out.println(Thread.currentThread().getName() + " end");
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }
     }
 }

 public class ThreadA extends Thread{
     MyObject myObject;
     public ThreadA(MyObject    myObject) {
         this.myObject = myObject;
     }

     @Override
     public void run() {
         super.run();
         myObject.methodA();
     }
 }

 public class ThreadB extends Thread{
     MyObject myObject;
     public ThreadB(MyObject    myObject) {
         this.myObject = myObject;
     }

     @Override
     public void run() {
         super.run();
         myObject.methodB(myObject);
     }
 }

 public class Main {
     public static void main(String[] args) {
         MyObject myObject = new MyObject();

         ThreadA threadA = new ThreadA(myObject);
         ThreadB threadB = new ThreadB(myObject);
         threadA.setName("A");
         threadB.setName("B");

         threadB.start();
         threadA.start();
     }
 }

Result

 B begin
 B end
 A begin
 A end

《Java多线程编程核心技术》学习