java同步通信方式_Java之线程安全中的三种同步方式

一个程序在运行起来时，会转换为进程，通常含有多个线程。

通常情况下，一个进程中的比较耗时的操作(如长循环、文件上传下载、网络资源获取等)，往往会采用多线程来解决。

比如，现实生活中，银行取钱问题、火车票多个窗口售票问题等，通常会涉及并发问题，从而需要用到多线程技术。

当进程中有多个并发线程进入一个重要数据的代码块时，在修改数据的过程中，很有可能引发线程安全问题，从而造成数据异常。例如，正常逻辑下，同一个编号的火车票只能售出一次，却由于线程安全问题而被多次售出，从而引起实际业务异常。

接下来，我以售票问题，来演示多线程问题中对核心数据保护的重要性。我们先来看不对多线程数据进行保护时会引发什么样的状况。

/**

* 售票问题

*/

public class Test1 {

static int tickets=10;

class SellTickets implements Runnable{

@Override

public void run() {

// 未加同步时,产生脏数据

while(tickets>0){

System.out.println(Thread.currentThread().getName()+" -->售出第 "+tickets+" 张票");

tickets--;

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

if(tickets<=0){

System.out.println(Thread.currentThread().getName()+" -->售票结束!");

}

}

}

public static void main(String[] args) {

SellTickets sell=new Test1().new SellTickets();

Thread t1=new Thread(sell, "1号窗口");

Thread t2=new Thread(sell, "2号窗口");

Thread t3=new Thread(sell, "3号窗口");

Thread t4=new Thread(sell, "4号窗口");

t1.start();

t2.start();

t3.start();

t4.start();

}

}

上述代码运行后，效果如下：

1号窗口 -->售出第 10 张票

3号窗口 -->售出第 10 张票

2号窗口 -->售出第 10 张票

4号窗口 -->售出第 10 张票

3号窗口 -->售出第 6 张票

2号窗口 -->售出第 6 张票

1号窗口 -->售出第 5 张票

4号窗口 -->售出第 3 张票

3号窗口 -->售出第 2 张票

2号窗口 -->售出第 2 张票

1号窗口 -->售出第 2 张票

4号窗口 -->售票结束!

3号窗口 -->售票结束!

1号窗口 -->售票结束!

2号窗口 -->售票结束!

上述运行结果中，第10张票被售出多次，显然不符合实际应用中的逻辑。由于多线程调度中的不确定性，读者在演示上述代码时，可能会取得不同的运行结果。

为了解决上述脏数据的问题，我为大家介绍3种使用比较普遍的三种同步方式。

第一种，同步代码块。

有synchronized关键字修饰的语句块，即为同步代码块。同步代码块会被JVM自动加上内置锁,从而实现同步。

我们来看代码：

/**

* 售票问题

* @author 李章勇

*

*/

public class Test2 {

static int tickets=10;

class SellTickets implements Runnable{

@Override

public void run() {

//同步代码块

while(tickets>0){

synchronized(this){

if(tickets<=0){

break;

}

System.out.println(Thread.currentThread().getName()+" -->售出第 "+tickets+" 张票");

tickets--;

}

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

if(tickets<=0){

System.out.println(Thread.currentThread().getName()+" -->售票结束!");

}

}

}

public static void main(String[] args) {

SellTickets sell=new Test2().new SellTickets();

Thread t1=new Thread(sell, "1号窗口");

Thread t2=new Thread(sell, "2号窗口");

Thread t3=new Thread(sell, "3号窗口");

Thread t4=new Thread(sell, "4号窗口");

t1.start();

t2.start();

t3.start();

t4.start();

}

}

上述代码运行结果：

1号窗口 -->售出第 10 张票

3号窗口 -->售出第 9 张票

4号窗口 -->售出第 8 张票

2号窗口 -->售出第 7 张票

3号窗口 -->售出第 6 张票

4号窗口 -->售出第 5 张票

2号窗口 -->售出第 4 张票

1号窗口 -->售出第 3 张票

4号窗口 -->售出第 2 张票

3号窗口 -->售出第 1 张票

1号窗口 -->售票结束!

2号窗口 -->售票结束!

4号窗口 -->售票结束!

3号窗口 -->售票结束!

通过运行结果可知，上述运行结果正常。

第二种，同步方法 。

即有synchronized关键字修饰的方法。由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

我们来看代码：

/**

* 售票问题

* @author 李章勇

*

*/

public class Test3 {

static int tickets=10;

class SellTickets implements Runnable{

@Override

public void run() {

//同步方法

while(tickets>0){

synMethod();

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

if(tickets<=0){

System.out.println(Thread.currentThread().getName()+" -->售票结束!");

}

}

//同步方法

synchronized void synMethod(){

synchronized(this){

if(tickets<=0){

return;

}

System.out.println(Thread.currentThread().getName()+" -->售出第 "+tickets+" 张票");

tickets--;

}

}

}

public static void main(String[] args) {

SellTickets sell=new Test3().new SellTickets();

Thread t1=new Thread(sell, "1号窗口");

Thread t2=new Thread(sell, "2号窗口");

Thread t3=new Thread(sell, "3号窗口");

Thread t4=new Thread(sell, "4号窗口");

t1.start();

t2.start();

t3.start();

t4.start();

}

}

上述代码运行结果：

1号窗口 -->售出第 10 张票

4号窗口 -->售出第 9 张票

3号窗口 -->售出第 8 张票

2号窗口 -->售出第 7 张票

1号窗口 -->售出第 6 张票

2号窗口 -->售出第 5 张票

4号窗口 -->售出第 4 张票

3号窗口 -->售出第 3 张票

4号窗口 -->售出第 2 张票

3号窗口 -->售出第 1 张票

1号窗口 -->售票结束!

4号窗口 -->售票结束!

2号窗口 -->售票结束!

3号窗口 -->售票结束!

上述代码运行结果也正常。

第三种，Lock锁机制。

通过创建Lock对象，采用lock()加锁，采用unlock()解锁，来保护指定代码块。我们看如下代码：

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

/**

* 售票问题

* @author 李章勇

*

*/

public class Test4 {

static int tickets=10;

class SellTickets implements Runnable{

Lock lock=new ReentrantLock();

@Override

public void run() {

//Lock锁机制

while(tickets>0){

try{

lock.lock();

if(tickets<=0){

break;

}

System.out.println(Thread.currentThread().getName()+" -->售出第 "+tickets+" 张票");

tickets--;

}finally{

lock.unlock();

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

if(tickets<=0){

System.out.println(Thread.currentThread().getName()+" -->售票结束!");

}

}

}

public static void main(String[] args) {

SellTickets sell=new Test4().new SellTickets();

Thread t1=new Thread(sell, "1号窗口");

Thread t2=new Thread(sell, "2号窗口");

Thread t3=new Thread(sell, "3号窗口");

Thread t4=new Thread(sell, "4号窗口");

t1.start();

t2.start();

t3.start();

t4.start();

}

}

运行结果如下：

1号窗口 -->售出第 10 张票

2号窗口 -->售出第 9 张票

3号窗口 -->售出第 8 张票

4号窗口 -->售出第 7 张票

1号窗口 -->售出第 6 张票

4号窗口 -->售出第 5 张票

2号窗口 -->售出第 4 张票

3号窗口 -->售出第 3 张票

1号窗口 -->售出第 2 张票

2号窗口 -->售出第 1 张票

3号窗口 -->售票结束!

1号窗口 -->售票结束!

2号窗口 -->售票结束!

4号窗口 -->售票结束!

最后总结：

由于synchronized是在JVM层面实现的，因此系统可以监控锁的释放与否；而ReentrantLock是使用代码实现的，系统无法自动释放锁，需要在代码中的finally子句中显式释放锁lock.unlock()。

另外，在并发量比较小的情况下，使用synchronized是个不错的选择；但是在并发量比较高的情况下，其性能下降会很严重，此时ReentrantLock是个不错的方案。

补充：

在使用synchronized 代码块时,可以与wait()、notify()、nitifyAll()一起使用，从而进一步实现线程的通信。

其中，wait()方法会释放占有的对象锁，当前线程进入等待池，释放cpu,而其他正在等待的线程即可抢占此锁，获得锁的线程即可运行程序；线程的sleep()方法则表示，当前线程会休眠一段时间，休眠期间，会暂时释放cpu，但并不释放对象锁，也就是说，在休眠期间，其他线程依然无法进入被同步保护的代码内部，当前线程休眠结束时，会重新获得cpu执行权,从而执行被同步保护的代码。

wait()和sleep()最大的不同在于wait()会释放对象锁，而sleep()不会释放对象锁。

notify()方法会唤醒因为调用对象的wait()而处于等待状态的线程，从而使得该线程有机会获取对象锁。调用notify()后，当前线程并不会立即释放锁，而是继续执行当前代码，直到synchronized中的代码全部执行完毕，才会释放对象锁。JVM会在等待的线程中调度一个线程去获得对象锁，执行代码。

需要注意的是，wait()和notify()必须在synchronized代码块中调用。

notifyAll()是唤醒所有等待的线程。

接下来，我们通过下一个程序，使得两个线程交替打印“A”和“B”各10次。请见下述代码：

public class Test5 {

static final Object obj=new Object();

//一个子线程

static class ThreadA implements Runnable{

@Override

public void run() {

int count=10;

while(count>0){

synchronized(Test5.obj){

System.out.println("A-->"+count);

count--;

Test5.obj.notify();

try {

Test5.obj.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

}

//另一个子线程

static class ThreadB implements Runnable{

@Override

public void run() {

int count=10;

while(count>0){

synchronized(Test5.obj){

System.out.println("B-->"+count);

count--;

Test5.obj.notify();

try {

Test5.obj.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

}

public static void main(String[] args) {

new Thread(new ThreadA()).start();

new Thread(new ThreadB()).start();

}

}

显示结果如下：

A-->10

B-->10

A-->9

B-->9

A-->8

B-->8

A-->7

B-->7

A-->6

B-->6

A-->5

B-->5

A-->4

B-->4

A-->3

B-->3

A-->2

B-->2

A-->1

B-->1