java 常用多线程同步_Java 多线程基础（五）线程同步

Java 多线程基础(五)线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。 要解决上述多线程并发访问一个资源的安全性问题，Java中提供了同步机制(synchronized)来解决。

一、线程同步

当线程A进入操作的时候，线程B和线程C只能在外等着，线程A操作结束，线程B和线程C才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕，数据同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

为了保证每个线程都能正常执行原子操作，Java引入了线程同步机制。线程同步机制主要synchronized关键字，给对象加锁的机制来保证线程的同步。

二、synchronized

(一)、synchronized的原理

在java中，每一个对象有且仅有一个同步锁。这也意味着，同步锁是依赖于对象而存在。

当我们调用某对象的 synchronized 方法时，就获取了该对象的同步锁。例如，synchronized(obj) 就获取了“obj这个对象”的同步锁。

不同线程对同步锁的访问是互斥的。也就是说，某时间点，对象的同步锁只能被一个线程获取到！通过同步锁，我们就能在多线程中，实现对“对象/方法”的互斥访问。 例如，现在有两个线程A和线程B，它们都会访问“对象obj的同步锁”。假设，在某一时刻，线程A获取到“obj的同步锁”并在执行一些操作；而此时，线程B也企图获取“obj的同步锁” —— 线程B会获取失败，它必须等待，直到线程A释放了“该对象的同步锁”之后线程B才能获取到“obj的同步锁”从而才可以运行。

(二)、synchronized的基本规则

我们将 synchronized 的基本规则总结为下面3条，并通过实例对它们进行说明。

第一条: 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的该“synchronized方法”或者“synchronized代码块”的访问将被阻塞。

第二条: 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程仍然可以访问“该对象”的非同步代码块。

第三条: 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对“该对象”的其他的“synchronized方法”或者“synchronized代码块”的访问将被阻塞。

1、第一条规则

1 public classDemo01 {2 public static voidmain(String[] args) {3 MyRunnable run = newMyRunnable();4 Thread t1 = newThread(run);5 Thread t2 = newThread(run);6 t1.start();7 t2.start();8 }9 }10 class MyRunnable implementsRunnable{11 @Override12 public voidrun() {13 synchronized (this) {14 try{15 for (int i = 0; i < 5; i++) {16 Thread.sleep(1000);//休眠1秒

17 System.out.println(Thread.currentThread().getName() + "---" +i);18 }19 }catch(Exception e) {20 e.printStackTrace();21 }22 }23 }24 }

// 执行结果：

Thread-0---0Thread-0---1Thread-0---2Thread-0---3Thread-0---4Thread-1---0Thread-1---1Thread-1---2Thread-1---3Thread-1---4

说明：run()方法中存在“synchronized(this)代码块”，而且t1和t2都是基于"run这个Runnable对象"创建的线程。这就意味着，我们可以将synchronized(this)中的this看作是“run这个Runnable对象”；因此，线程t1和t2共享“run对象的同步锁”。所以，当一个线程运行的时候，另外一个线程必须等待“运行线程”释放“run的同步锁”之后才能运行。

2、第二条规则

public classDemo01 {public static voidmain(String[] args) {

Demo01 demo= newDemo01();new Thread(() ->{

demo.synCount();

}).start();//Lambda方式启动线程

new Thread(() ->{

demo.notSynCount();

}).start();//Lambda方式启动线程

}//同步代码块的方法

public voidsynCount() {synchronized (this) {try{for(int i = 0;i <5;i++) {

Thread.sleep(1000);//休眠1秒

System.out.println(Thread.currentThread().getName() + " syn count method " +i);

}

}catch(Exception e) {

e.printStackTrace();

}

}

}//非同步的方法

public voidnotSynCount() {try{for(int i = 0;i <5;i++) {

Thread.sleep(1000);//休眠1秒

System.out.println(Thread.currentThread().getName() + " not syn count method " +i);

}

}catch(Exception e) {

e.printStackTrace();

}

}

}

//运行结果

Thread-0 syn count method 0Thread-1 not syn count method 0Thread-1 not syn count method 1Thread-0 syn count method 1Thread-0 syn count method 2Thread-1 not syn count method 2Thread-0 syn count method 3Thread-1 not syn count method 3Thread-0 syn count method 4Thread-1 not syn count method 4

说明：主线程中通过Lambda方式新建了两个子线程Thread-0和Thread-1。Thread-0会调用demo对象的synCount()方法，该方法内含有同步块；而THread-1则会调用demo对象的notSynCount()方法，该方法不是同步方法。Thread-0运行时，虽然调用synchronized(this)获取“demo的同步锁”；但是并没有造成t2的阻塞，因为Thread-1没有用到“demo”同步锁。

3、第三条规则

public classDemo01 {public static voidmain(String[] args) {

Demo01 demo= newDemo01();new Thread(() ->{

demo.synCount();

}).start();//Lambda方式启动线程

new Thread(() ->{

demo.notSynCount();

}).start();//Lambda方式启动线程

}//同步代码块的方法

public voidsynCount() {synchronized (this) {try{for(int i = 0;i <5;i++) {

Thread.sleep(1000);//休眠1秒

System.out.println(Thread.currentThread().getName() + " syn count method " +i);

}

}catch(Exception e) {

e.printStackTrace();

}

}

}//同步代码块的方法

public voidnotSynCount() {synchronized(this) {try{for(int i = 0;i <5;i++) {

Thread.sleep(1000);//休眠1秒

System.out.println(Thread.currentThread().getName() + " not syn count method " +i);

}

}catch(Exception e) {

e.printStackTrace();

}

}

}

}

//运行结果

Thread-0 syn count method 0Thread-0 syn count method 1Thread-0 syn count method 2Thread-0 syn count method 3Thread-0 syn count method 4Thread-1 not syn count method 0Thread-1 not syn count method 1Thread-1 not syn count method 2Thread-1 not syn count method 3Thread-1 not syn count method 4

说明：主线程中新建了两个子线程Thread-0和Thread-1。两者运行时都调用synchronized(this)，这个this是demo对象，而两者共用demo对象。因此，在Thread-0运行时，Thread-1会被阻塞，等待Thread-0运行释放“demo对象的同步锁”，Thread-1才能运行。

三、线程同步的方式

(一)、同步代码块

同步代码块是通过 synchronized 关键字修饰程序的代码块，synchronized  关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。格式示例如下：

public voidcount{synchronized (this) {for (int i = 0; i < 5; i++) {

System.out.println(i);

}

}

]

(二)、同步方法

同步方法是用 synchronized 关键字修饰方法，保证A线程执行该方法的时候,其他线程只能在方法外等候。格式示例如下：

public synchronized voidcount() {for(int i = 0;i <5;i++) {

System.out.println(i);

}

}

四、全局锁和实例锁

(一)、全局锁：该锁针对的是类，无论实例多少个对象，那么线程都共享该锁。全局锁对应的就是 static synchronized(或者是锁在该类的class或者classloader对象上)。

(二)、示例锁：锁在某一个实例对象上。如果该类是单例，那么该锁也具有全局锁的概念。实例锁对应的就是 synchronized关键字。

关于实例锁和全局锁有一个很形象的例子：

pulbic classSomething {public synchronized voidisSyncA(){}public synchronized voidisSyncB(){}public static synchronized voidcSyncA(){}public static synchronized voidcSyncB(){}

}

假设，Something有两个实例x和y。分析下面4组表达式获取的锁的情况。

1、x.isSyncA() 与 x.isSyncB()

2、x.isSyncA() 与 y.isSyncA()

3、x.cSyncA() 与 y.cSyncB()

4、x.isSyncA() 与 Something.cSyncA()

1、不能被同时访问：因为 isSyncA() 和 isSyncB() 都是访问同一个对象(对象x)的同步锁！

2、可以被同时访问：因为访问的不是同一个对象的同步锁，x.isSyncA() 访问的是 x 的同步锁，而 y.isSyncA() 访问的是 y 的同步锁。

3、不能被同时访问：因为 cSyncA() 和 cSyncB() 都是 static 类型，x.cSyncA() 相当于 Something.isSyncA()，y.cSyncB() 相当于Something.isSyncB()，因此它们共用一个同步锁，不能被同时访问。

4、可以被同时访问：因为 isSyncA() 是实例方法，x.isSyncA() 使用的是对象x的锁；而 cSyncA() 是静态方法，Something.cSyncA() 可以理解对使用的是“类的锁”。因此，它们是可以被同时访问的。