线程安全——线程经典面试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
整体思想是：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();
}
}