Java多线程同步的五种方法

时间:2022-02-16 15:09:26

一、目的

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

二、为什么要线程同步

  • 因为当我们有多个线程要同时访问一个变量或对象时,如果这些线程中既有读又有写操作时,就会导致变量值或对象的状态出现混乱,从而导致程序异常。
  • 比如一个银行账户,一个取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