目录
多线程-高级主题
1.定时调度
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Timer;
import java.util.TimerTask;
/*
* 任务定时调度
* */
public class MyTimerTest01 {
public static void main(String[] args) {
Timer timer = new Timer();
//1000表示延迟1秒开始调用run方法,2000表示以后每次调用run方法隔了2秒
timer.schedule(new MyTask(),1000,2000);//执行多次
timer.schedule(new MyTask(),1000);//只执行一次
//指定具体开始执行时间
Calendar cal = new GregorianCalendar(2022,12,30,20,20,20);
timer.schedule(new MyTask(),cal.getTime(),2000);//
}
}
//任务类
class MyTask extends TimerTask{
@Override
public void run() {
System.out.println("休息中");
}
}
2.HappenBefore
java有可能出现 代码没有按照编写的时候顺序执行的情况,因为编译器和CPU会尝试重排指令使得代码更快地运行。这个情况一般发生在代码块与代码块没有依赖关系的时候。
代码执行的四个步骤:(1)拿到指令 (2)解码翻译 (3)做操作 (4)写回。
/*
* 指令重排:代码执行顺序与预期不一致
* 目的:自动提高性能
* */
public class HappenBefore {
private static int a=0;
private static boolean flag = false;
public static void main(String[] args) {
//线程1
Thread t1 = new Thread(()->{
a = 1;
flag = true;
});
//线程2
Thread t2 = new Thread(()->{
if(flag){
a*=1;
}
if(a==0){
System.out.println("happen before a:"+ a);
}
});
t1.start();
t2.start();
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行结果:会有小概率的情绪执行a==0的if语句,有打印出结果。
3.volatile
volatile保证线程间变量的可见性。(volatile是一种关键字,保证多线程的数据同步,目前基本不用了,机器会及时同步)
4.单例模式
单例模式:单例模式是一种设计模式,在多线程环境下,对外只存在一个对象。
/*
* 单例模式 --懒汉式套路基础加入并发控制
* 1、构造器私有化 --避免外部new构造器
* 2、提供私有的静态属性 --存储对象的地址
* 3、提供公共的静态方法 --获取属性
* */
public class DoubleCheckedLocking {
//提供私有的静态属性
//没有volatile 可能会出现指令重排,导致其他线程可能访问一个没有初始化的对象
private static volatile DoubleCheckedLocking instance;
//构造器私有化
private DoubleCheckedLocking(){
}
//提供公共的静态方法
public static DoubleCheckedLocking getInstance(){
if(null!=instance){ //已经存在对象,避免不必要的同步
return instance;
}
synchronized (DoubleCheckedLocking.class){
if(null == instance){
instance = new DoubleCheckedLocking();
}
}
return instance;
}
public static void main(String[] args) {
Thread t = new Thread(()->{
System.out.println(DoubleCheckedLocking.getInstance());
});
t.start();
}
}
5.ThreadLcoal
ThreadLocal的目的是为了在多线程环境下保证成员变量的安全,让线程使用自己的局部变量。
/*
* ThreadLocal:每个线程自身的存储本地、局部区域
* */
public class ThreadLocalTest01 {
private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>(){
protected Integer initialValue(){
return 200;
};
};
//简化方式
// private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(()->{
// return 200;
// });
public static void main(String[] args) {
//获取值
System.out.println(Thread.currentThread().getName()+"---"+threadLocal.get());
//设置值
threadLocal.set(99);
System.out.println(Thread.currentThread().getName()+"---"+threadLocal.get());
}
}
ThreadLocal:每个线程自身的存储本地、局部区域。(每个线程有自己的存储空间,互不侵犯)
6.可重入锁
可重入就是说某个线程已经获得某个锁,可以再次获取锁而不会出现死锁。目的:锁可以重复使用。
可重入锁有 (1)synchronized (2)ReentrantLock
ReentrantLock 和 synchronized 不一样,需要手动释放锁,所以使用 ReentrantLock的时候一定要手动释放锁,并且加锁次数和释放次数要一样。
import java.util.Random;
import java.util.concurrent.locks.ReentrantLock;
public class LocalTest {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
new Thread(new Runnable() {
@Override
public void run() {
try {
lock.lock();
System.out.println("第1次获取锁,这个锁是:" + lock);
int index = 1;
while (true) {
try {
lock.lock();
System.out.println("第" + (++index) + "次获取锁,这个锁是:" + lock);
try {
Thread.sleep(new Random().nextInt(200));
} catch (InterruptedException e) {
e.printStackTrace();
}
if (index == 4) {
break;
}
} finally {
lock.unlock();
}
}
} finally {
lock.unlock();
}
}
}).start();
}
}
运行结果:
7.CAS
CAS是CompareAndSwap的缩写,中文意思是:比较并替换。CAS需要有3个操作数:内存地址V,旧的预期值A,即将要更新的目标值B。
CAS指令执行时,当且仅当内存地址V的值与预期值A相等时,将内存地址V的值修改为B,否则就什么都不做。整个比较并替换的操作是一个原子操作。
CAS虽然很高效的解决了原子操作问题,但是CAS仍然存在三大问题。
- 循环时间长开销很大。
- 只能保证一个共享变量的原子操作。
- ABA问题。(如果在这段期间它的值曾经被改成了B,后来又被改回为A,那CAS操作就会误认为它从来没有被改变过。这个漏洞称为CAS操作的“ABA”问题。)