线程安全
- 线程安全概念：当多个线程访问某一个类（对象或方法）时，这个类始终都能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。
- synchronized：可以在任意对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”。
- 当多个线程访问myThread的run方法时，以排队的方式进行处理（这里排对是按照CPU分配的先后顺序而定的），一个线程想要执行synchronized修饰的方法里的代码，首先是尝试获得锁，如果拿到锁，执行synchronized代码体内容；拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁。（也就是会有锁竞争的问题）
线程不安全
package com.example.core.safely;
public class MyThread extends Thread{
private int count = 5;
public void run(){
count--;
System.out.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();
}
}
线程安全 -> 添加synchronized
- synchronized 同步的概念就是共享，我们要牢牢记住"共享"这俩个字，如果不是共享的资源，就没有必要进行同步。
- 异步：asynchronized 异步的概念就是独立，相互之间不受到任何制约。就好像我们学习http的时候，在页面发起的Ajax请求，我们还可以继续浏览或操作页面的内容，二者之间没有任何关系
- 同步的目的就是为了线程安全，其实对于线程安全来说，需要满足俩个特性： 原子性（同步） 可见性
package com.example.core.safely;
public class MyThread extends Thread{
private int count = 5;
public synchronized void run(){
count--;
System.out.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();
}
}
线程之间的通信
- 线程通信概念：线程是操作系统中独立的个体，但这些个体如果不经过特殊的处理就不能成为一个整体，线程间的通信就成为整体的必用方式之一。当线程存在通信指挥，系统间的交互性会更强大，在提高CPU利用率的同时还会使开发人员对线程任务在处理的过程中进行有效的把控与监督
- 使用wait / notify 方法实现线程间的通信。（注意这两个方法都是object的类的方法，换句话说java为所有的对象都提供了这两个方法） wait 和 notify 必须配合 synchronized 关键字使用 wait方法释放锁，notify方法不释放锁
ThreadLocal
- 线程局部变量，是一种多线程间并发访问变量的解决方案。与其synchronized等加锁的方式不同，ThreadLocal完全不提供锁，而使用以空间换时间的手段，为每个线程提供变量的独立副本，以保障线程安全
- 从性能上说，ThreadLocal不具有绝对的优势，在并发不是很高的时候，加锁的性能会更好，但作为一套与锁完全无关的线程安全解决方案，在高并发量或者竞争激烈的场景，使用ThreadLocal可以在一定程度上减少锁竞争
package com.example.core.safely;
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.out.println("当前值"+utl.getThreadLocal());
}
}
问题
- 如题，有两个线程A、B，A线程向一个集合(List<String>) 里面依次添加元素“abc”字符串, 一共添加十次，当添加到第五次的时候，希望B线程能够收到A线程的通知，然后B线程执行相关的业务操作，我们应该如何进行设计？
1，使用CountDownLatch
-
latch.countDown();//唤醒通知
-
latch.await();//阻塞
package com.example.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);//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();
}
}
2，使用volalite关键字
package com.example.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();
}
}
3，使用synchronized配合使用wait和notify
package com.example.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();
}
}
扫一扫
415
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
