线程安全——线程经典面试Synchronized/CountDownLatch/volatile

Synchronized（同步）

同步：synchronized
    同步的概念就是共享，我们要牢牢记住"共享"这俩个字，如果不是共享的资源，
就没有必要进行同步。
异步：asynchronized(伪代码不是JDK代码)
    异步的概念就是独立，相互之间不受到任何制约。就好像我们学习http的时候，
在页面发起的Ajax请求，我们还可以继续浏览或操作页面的内容，二者之间没有任何关系。
    同步的目的就是为了线程安全，其实对于线程安全来说，需要满足俩个特性：
    原子性（同步）
    可见性		

线程之间通信（ wait 和 notify 必须配合 synchronized 关键字使用 wait方法释放锁，notify方法不释放锁）

线程通信概念：
    线程是操作系统中独立的个体，但这些个体如果不经过特殊的处理就不
能成为一个整体，线程间的通信就成为整体的必用方式之一。当线程存在通信指挥，系
统间的交互性会更强大，在提高CPU利用率的同时还会使开发人员对线程任务在处理的过
程中进行有效的把控与监督。
    使用wait / notify 方法实现线程间的通信。（注意这两个方法都是object的类的方法，
换句话说java为所有的对象都提供了这两个方法）
    wait 和 notify 必须配合 synchronized 关键字使用
    wait方法释放锁，notify方法不释放锁

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

整体思想是：B线程等待被唤醒执行业务。

final Object lock = new Object();//定义对象锁，供两个线程之间通信

等待的代码用while(true)循环，A线程写唤醒B的逻辑

没有及时通知B线程处理任务

package com.bfxy.thread.core.safely;

import java.util.ArrayList;
import java.util.List;

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("已经发出了唤醒通知!");
								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 {
								lock.wait();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
					}
					//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循环结束后才唤醒B，是因为wait方法释放锁，notify方法不释放锁

2方法二设计

不使用synchronized，不使用lock

final CountDownLatch latch = new CountDownLatch(1);//想发出一个通知

A线程：

latch.countDown();//countDown的次数对应new CountDownLatch(1)

B：线程：

latch.await();//

package com.bfxy.thread.core.safely;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

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();
		
		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("已经发出了唤醒通知!");
								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 {
								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执行中就唤醒B线程。而不是在A执行后才会执行B.

方法三：volatile关键字

// 1 定义的承装字符串的容器
private volatile static List list = new ArrayList();   //被volatile修饰的变量（共享变量）会在多个线程可见

package com.bfxy.thread.core.safely;

import java.util.ArrayList;
import java.util.List;

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();
		
	}
	
}