Java多线程同步的五种方法

点滴~

已于 2023-11-17 13:58:46 修改

阅读量2.5k

点赞数

分类专栏： Java多线程面试文章标签： Java多线程同步

于 2018-06-11 15:54:37 首次发布

本文链接：https://blog.csdn.net/oqkdws/article/details/80648839

版权

Java多线程同时被 2 个专栏收录

17 篇文章 0 订阅

订阅专栏

面试

14 篇文章 0 订阅

订阅专栏

一、目的

有赞突击面试，毫无防备，这个问题好像被别的公司也问过，没答上来，所以总结一下。

二、为什么要线程同步

因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。
比如一个银行账户，一个取100元，一个存100元。假设原来只有0元，看看会出现什么结果。

三、不同情况下的结果

不使用同步方法：

package com.thread.test;



public class Bank {
	private int count = 0; //银行账户
	
	//存钱
	public void addMoney( int money) {
		count += money;
		System.out.println(System.currentTimeMillis()+"存进：" +money);
	}
	
	//取钱
	public void subMoney(int money) {
		if(count-money<0){
			System.out.println("余额不足");
			return;
		}
		
		count -= money;
		System.out.println(+System.currentTimeMillis()+"取出+"+money);
		
	}
	
	//查询
	public void lookMoney() {
		System.out.println("账户余额：" +count);
	}

}

package com.thread.test;

public class SyncThreadTest {
	public static void main(String[] args) {
		final Bank bank = new Bank();
		
		Thread tadd = new Thread(new Runnable() {
			
			@Override
			public void run() {
				while(true) {
					try{
						Thread.sleep(100);
					}catch (Exception e) {
						e.printStackTrace();
					}
					bank.addMoney(100);
					bank.lookMoney();
					System.out.println("\n");
				}
			}
		});
		
		Thread tsub = new Thread(new Runnable() {
					
					@Override
					public void run() {
						while(true) {
							try{
								Thread.sleep(1000);
							}catch (Exception e) {
								e.printStackTrace();
							}
							bank.subMoney(100);
							bank.lookMoney();
							System.out.println("\n");
						}
					}
				});
		
		tsub.start();
		tadd.start();
	}
}

两个进程：（1）存钱，（2）取钱。

1528689141841存进：100
账户余额：100
1528689141942存进：100
账户余额：200
1528689142042存进：100
账户余额：300
1528689142142存进：100
账户余额：400

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

package com.thread.test;

public class SynchronizedBank {
	private int count = 0; //银行账户
	
	//存钱
	public synchronized void addMoney( int money) {
		count += money;
		System.out.println(System.currentTimeMillis()+"存进：" +money);
	}
	
	//取钱
	public synchronized void subMoney(int money) {
		if(count-money<0){
			System.out.println("余额不足");
			return;
		}
		
		count -= money;
		System.out.println(+System.currentTimeMillis()+"取出+"+money);
	}
	
	//查询
	public void lookMoney() {
		System.out.println("账户余额：" +count);
	}
}

结果：

1528697968158存进：100
账户余额：100


1528697968162取出+100
账户余额：0


1528697969159存进：100
账户余额：100


1528697969163取出+100
账户余额：0

（2）synchronized关键字同步代码块
被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

package com.thread.test;

public class SynchronizedBank_block {
	private int count = 0; //银行账户
	
	//存钱
	public void addMoney( int money) {
		
		synchronized (this) {
			count += money;
		}
		System.out.println(System.currentTimeMillis()+"存进：" +money);
	}
	
	//取钱
	public synchronized void subMoney(int money) {
		
		synchronized(this){
			
		if(count-money<0){
			System.out.println("余额不足");
			return;
		}
		count -= money;
		}
		
		System.out.println(+System.currentTimeMillis()+"取出+"+money);
	}
	
	//查询
	public void lookMoney() {
		System.out.println("账户余额：" +count);
	}
}

运行结果：

1528699402342取出+100
账户余额：0


1528699403346存进：100
账户余额：100


1528699403347取出+100
账户余额：0


1528699404347存进：100
账户余额：100

注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

（3）使用特殊域变量(volatile)实现线程同步

volatile关键字为域变量的访问提供了一种免锁机制
使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新
因此每次使用该域就要重新计算，而不是使用寄存器中的值
volatile不会提供任何原子操作，它也不能用来修饰final类型的变量

package com.thread.test;

public class VolatileBank {
	private volatile int count = 0; //银行账户
	
	//存钱
	public void addMoney( int money) {
		count += money;
		System.out.println(System.currentTimeMillis()+"存进：" +money);
	}
	
	//取钱
	public void subMoney(int money) {
		if(count-money<0){
			System.out.println("余额不足");
			return;
		}
		
		count -= money;
		System.out.println(+System.currentTimeMillis()+"取出+"+money);
		
	}
	
	//查询
	public void lookMoney() {
		System.out.println("账户余额：" +count);
	}

}

余额不足
账户余额：0


1528700014203存进：100
账户余额：100


1528700015198取出+100
账户余额：0


1528700015203存进：100
账户余额：100


1528700016198取出+100
账户余额：0


1528700016203存进：100
账户余额：100

因为volatile不能保证原子操作导致的，因此volatile不能代替synchronized。
此外volatile会组织编译器对代码优化，因此能不使用它就不适用它吧。
它的原理是每次要线程要访问volatile修饰的变量时都是从内存中读取，而不是存缓存当中读取，因此每个线程访问到的变量值都是一样的。这样就保证了同步。
（4）使用ReentrantLock的重入锁实现线程同步

在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁，它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。
ReenreantLock类的常用方法有：
ReentrantLock() : 创建一个ReentrantLock实例
lock() : 获得锁
unlock() : 释放锁

注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用

1528700957237存进：100
账户余额：100


1528700958238取出+100
账户余额：0


1528700958238存进：100
账户余额：100


1528700959238存进：100
1528700959238取出+100
账户余额：100


账户余额：100


1528700960239存进：100
账户余额：200


1528700960240取出+100
账户余额：100

如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码。
如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁。

（5）使用局部变量ThreadLocal实现线程同步

package com.thread.test;

public class ThreadLocalBank {
	private static ThreadLocal<Integer> count = new ThreadLocal<Integer>(){
		
		 @Override
		 protected Integer initialValue() {
		        return 10000;
		    }
	};
	
	//存钱
	public void addMoney( int money) {
		count.set(count.get()+money);
		System.out.println(System.currentTimeMillis()+"存进：" +money);
	}
	
	//取钱
	public void subMoney(int money) {
		if(count.get()-money<0){
			System.out.println("余额不足");
			return;
		}
		
		count.set(count.get()-money);;
		System.out.println(+System.currentTimeMillis()+"取出: "+money);
		
	}
	
	//查询
	public void lookMoney() {
		System.out.println("账户余额：" +count.get());
	}

}

结果：

1528703214170取出: 100
账户余额：9900


1528703214170存进：100
账户余额：10100


1528703215171取出: 100
账户余额：9800


1528703215172存进：100
账户余额：10200


1528703216171取出: 100
账户余额：9700


1528703216172存进：100
账户余额：10300


1528703217171取出: 100
账户余额：9600


1528703217172存进：100
账户余额：10400


1528703218171取出: 100
账户余额：9500


1528703218172存进：100
账户余额：10500


1528703219171取出: 100
账户余额：9400


1528703219173存进：100
账户余额：10600


1528703220171取出: 100
账户余额：9300


1528703220173存进：100
账户余额：10700

如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。
现在明白了吧，原来每个线程运行的都是一个副本，也就是说存钱和取钱是两个账户，知识名字相同而已。所以就会发生上面的效果。

参考：https://blog.csdn.net/wenwen091100304/article/details/48318699