Java学习笔记-并发编程-1.2线程安全

1.2线程安全

线程安全、Synchronized核心概念

线程安全

线程安全概念：当多个线程访问某一个类（对象或方法）时，这个类始终都能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。

synchronized：可以在任意对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”。

当多个线程访问myThread的run方法时，以排队的方式进行处理（这里排对是按照CPU分配的先后顺序而定的），一个线程想要执行synchronized修饰的方法里的代码，首先是尝试获得锁，如果拿到锁，执行synchronized代码体内容；拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁。（也就是会有锁竞争的问题）。

public class MyThread extends Thread {

	private int count = 5;
	
    // run()方法加了synchronized关键字，该方法被上了锁
	public synchronized void run(){
		count--;
		System.err.println(this.currentThread().getName() + " count = " + count);
	}
	
	public static void main(String[] args) {
		
		MyThread my = new MyThread();
		
		Thread t1 = new Thread(my, "t1");
		Thread t2 = new Thread(my, "t2");
		Thread t3 = new Thread(my, "t3");
		Thread t4 = new Thread(my, "t4");
		Thread t5 = new Thread(my, "t5");
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
		
	}
	
}
//run()方法不加了synchronized关键字运行3次的结果
t3 count = 4	|t2 count = 3	|t2 count = 3	
t4 count = 3	|t4 count = 2	|t4 count = 2
t1 count = 2	|t1 count = 3	|t1 count = 1
t5 count = 0	|t3 count = 1	|t3 count = 3
t2 count = 1	|t5 count = 0	|t5 count = 0

//run()方法加了synchronized关键字运行3次的结果
t1 count = 4	|t1 count = 4	|t1 count = 4
t5 count = 3	|t5 count = 3	|t4 count = 3
t4 count = 2	|t3 count = 2	|t3 count = 2
t3 count = 1	|t4 count = 1	|t2 count = 1
t2 count = 0	|t2 count = 0	|t5 count = 0
    
    

synchronized

同步：synchronized
同步的概念就是共享，我们要牢牢记住"共享"这俩个字，如果不是共享的资源，就没有必要进行同步。

异步：asynchronized
异步的概念就是独立，相互之间不受到任何制约。就好像我们学习http的时候，在页面发起的Ajax请求，我们还可以继续浏览或操作页面的内容，二者之间没有任何关系。

同步的目的就是为了线程安全，其实对于线程安全来说，需要满足俩个特性：

• 原子性（同步）
• 可见性

线程通讯

线程通信概念：线程是操作系统中独立的个体，但这些个体如果不经过特殊的处理就不能成为一个整体，线程间的通信就成为整体的必用方式之一。

当线程存在通信指挥，系统间的交互性会更强大，在提高CPU利用率的同时还会使开发人员对线程任务在处理的过程中进行有效的把控与监督。

使用wait / notify 方法实现线程间的通信。（注意这两个方法都是object的类的方法，换句话说java为所有的对象都提供了这两个方法）

• wait 和 notify 必须配合 synchronized 关键字使用
• wait方法释放锁，notify方法不释放锁

​

Q：如题，有两个线程A、B，A线程向一个集合(List) 里面依次添加元素“abc”字符串, 一共添加十次，当添加到第五次的时候，希望B线程能够收到A线程的通知，然后B线程执行相关的业务操作，我们应该如何进行设计？

方案1 synchronized

//方案1使用了synchronized的对象锁

public class ListAdd1 {

	// 1 定义的承装字符串的容器
	private static List list = new ArrayList();	
	
	// 2 追加方法
	public void add(){
		list.add("bfxy");
	}
	public int size(){
		return list.size();
	}
	
	public static void main(String[] args) {
		
		final ListAdd1 list1 = new ListAdd1();
		
		final Object lock = new Object();
		
		// 线程A
		Thread A = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
                    //添加对象锁
					synchronized (lock) {
						for(int i = 0; i <10; i++){
							list1.add();
							System.out.println("当前线程：" + Thread.currentThread().getName() + ", 添加了一个元素..");
							Thread.sleep(500);
							if(list.size() == 5) {
								System.err.println("已经发出了唤醒通知!");
                                //notify()唤醒线程，但是不释放锁，需要等该代码块完成执行才能释放
								lock.notify();
							}
						}						
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "A");
		
		
		// 线程B
		Thread B = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					synchronized (lock) {
						if(list1.size() != 5) {
							try {
                                //等待唤醒，wait()会释放锁，因此虽然B线程先运行，但是A线程仍可获取锁
								lock.wait();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
					}
					System.out.println("当前线程收到通知：" + Thread.currentThread().getName() + " list size = 5 线程停止..");
					throw new RuntimeException();
				}
			}
		}, "B");	
		
		B.start();
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		A.start();
		
	}

}

//运行结果
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
已经发出了唤醒通知!
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程收到通知：B list size = 5 线程停止..
Exception in thread "B" java.lang.RuntimeException
	at safely.ListAdd1$2.run(ListAdd1.java:64)
	at java.lang.Thread.run(Thread.java:748)

该结果中，由于A线程使用notify()是不释放锁的，因此B线程即使被唤醒，仍要等待A线程运行完成才能执行，跟预想中B线程被唤醒后立刻执行业务不符。

方案2 CountDownLatch

//方案2使用了 CountDownLatch
//CountDownLatch 是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
//用给定的计数初始化 CountDownLatch。由于调用了 countDown() 方法，
//所以在当前计数到达零之前，await() 方法会一直受阻塞。

public class ListAdd2 {

	// 1 定义的承装字符串的容器
	private static List list = new ArrayList();	
	
	// 2 追加方法
	public void add(){
		list.add("bfxy");
	}
	public int size(){
		return list.size();
	}
	
	public static void main(String[] args) {
		
		final ListAdd2 list1 = new ListAdd2();
		
        //需要递减的锁的数量为1
		final CountDownLatch latch = new CountDownLatch(1);
		
		// 线程A
		Thread A = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
						for(int i = 0; i <10; i++){
							list1.add();
							System.out.println("当前线程：" + Thread.currentThread().getName() + ", 添加了一个元素..");
							Thread.sleep(500);
							if(list.size() == 5) {
								System.err.println("已经发出了唤醒通知!");
                                // 锁的数量-1
								latch.countDown();
							}
						}						
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "A");
		
		
		// 线程B
		Thread B = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
						if(list1.size() != 5) {
							try {
                                //等待唤醒，当倒数为0时被唤醒
								latch.await();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
					}
					System.out.println("当前线程收到通知：" + Thread.currentThread().getName() + " list size = 5 线程停止..");
					throw new RuntimeException();
				}
			}
		}, "B");	
		
		B.start();
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		A.start();
		
	}
	
	
}

//运行结果
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
已经发出了唤醒通知!
Exception in thread "B" java.lang.RuntimeException
	at safely.ListAdd2$2.run(ListAdd2.java:60)
	at java.lang.Thread.run(Thread.java:748)
当前线程：A, 添加了一个元素..
当前线程收到通知：B list size = 5 线程停止..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
    
当A线程循环5次之后，倒数被减为0，B线程被唤醒

方案3 volatile

//使用了volatile 关键词修饰容器，使得容器可以在两个线程中共享

public class ListAdd3 {

	// 1 定义的承装字符串的容器
	private volatile static List list = new ArrayList();	
	
	// 2 追加方法
	public void add(){
		list.add("bfxy");
	}
	public int size(){
		return list.size();
	}
	
	public static void main(String[] args) {
		
		final ListAdd3 list1 = new ListAdd3();
		
		// 线程A
		Thread A = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
						for(int i = 0; i <10; i++){
							list1.add();
							System.out.println("当前线程：" + Thread.currentThread().getName() + ", 添加了一个元素..");
							Thread.sleep(500);
						}						
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "A");
		
		
		// 线程B
		Thread B = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					if(list1.size() == 5){
						System.out.println("当前线程收到通知：" + Thread.currentThread().getName() + " list size = 5 线程停止..");
						throw new RuntimeException();
					}
				}
			}
		}, "B");	
		
		B.start();
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		A.start();
		
	}
}

//运行结果
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程收到通知：B list size = 5 线程停止..
Exception in thread "B" java.lang.RuntimeException
	at safely.ListAdd3$2.run(ListAdd3.java:47)
	at java.lang.Thread.run(Thread.java:748)
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
当前线程：A, 添加了一个元素..
    
该方案中，容器被设定为线程共享，因此A线程在写入内容到list中时，B线程也在不断读list的长度，当B线程读取到list长度为5时，便执行自身的业务。

ThreadLocal线程局部变量使用与实战

线程局部变量，是一种多线程间并发访问变量的解决方案。与其synchronized等加锁的方式不同，ThreadLocal完全不提供锁，而使用以空间换时间的手段，为每个线程提供变量的独立副本**，以保障线程安全。

从性能上说，ThreadLocal不具有绝对的优势，在并发不是很高的时候，加锁的性能会更好，但作为一套与锁完全无关的线程安全解决方案，在高并发量或者竞争激烈的场景，使用ThreadLocal可以在一定程度上减少锁竞争。

public class UseThreadLocal {

	public static ThreadLocal<String> threadLocal = new ThreadLocal<>();
	
	public void setThreadLocal(String value) {
		threadLocal.set(value);
	}
	
	public String getThreadLocal(){
		return threadLocal.get();
	}
	
	public static void main(String[] args) {
		
		UseThreadLocal utl = new UseThreadLocal();
		
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				utl.setThreadLocal("张三");
				System.err.println("当前t1: " + utl.getThreadLocal());
			}
		}, "t1");
		
		
		Thread t2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
					utl.setThreadLocal("李四");
					System.err.println("当前t2: " + utl.getThreadLocal());
			}
		}, "t2");
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t1.start();
		t2.start();
		System.err.println("当前值: " + utl.getThreadLocal());
	}
	

}

//输出结果
当前值: null
当前t1: 张三
当前t2: 李四

ThreadLocal的应用，线程消息获取

实现代码：

public class MessageHolder {

	private List<String> messages = new ArrayList<>();
	
	public static final ThreadLocal<MessageHolder> holder = new ThreadLocal(){
		@Override
		protected Object initialValue(){
			return new MessageHolder();
		}
	};
	
	public static void add(String message) {
		holder.get().messages.add(message);
	}
	
	public static List<String> clear(){
		List<String> result = holder.get().messages;
		holder.remove();
		System.err.println("size: " + holder.get().messages.size());
		return result;
	}
	
	public static void main(String[] args) {
		 
		MessageHolder.add("1111");
		MessageHolder.add("2222");
		
		List<String> result = MessageHolder.clear();
		System.err.println(result.toString());
	}
	
}
// 运行结果
size: 0
[1111, 2222]

​

并发编程线程安全问题