文章目录
- 前言
- 1 线程池
- 1.1 线程池概述
- 1.1.1 线程池存在的意义
- 1.1.2 Executors默认线程池
- 1.2 线程状态介绍
- 1.2.1 线程状态源码
- 1.2.2 线程状态含义
- 1.2.3 线程状态转换图
- 2 原子性
- 2.1 volatile关键字
- 2.2 synchronized解决
- 2.3 原子性
- 2.4 AtomicInteger类
- 2.5 悲观锁和乐观锁
前言
“清琴浊酒莺花日，雨笠烟蓑蟹稻乡。棠荫渐高身渐隐，已将心事托渔郎” —张英 《赠何匡山次梅村先生韵》
1 线程池
1.1 线程池概述
线程池也是可以看做成一个容器，在该容器中存储很多个线程。
1.1.1 线程池存在的意义
系统创建一个线程的成本是比较高的，频繁的创建和销毁线程对系统的资源消耗非常大，所为了提高性能，我们就可以采用线程池。线程池在启动的时，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就会启动一个线程来执行该任务。等待任务执行完毕以后，线程并不会死亡，而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。
1.1.2 Executors默认线程池
1.常见方法
// 1.创建一个默认的线程池
static ExecutorService newCachedThreadPool()
// 2.创建一个指定最多线程数量的线程池
static newFixedThreadPool(int nThreads)
2.代码实现 :
package com.syh;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MyThread {
public static void main(String[] args) throws InterruptedException {
// 1,创建一个默认的线程池对象
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.submit(()->{
System.out.println(Thread.currentThread().getName() + "在执行了");
});
// 2,等待2秒
Thread.sleep(2000);
executorService.submit(()->{
System.out.println(Thread.currentThread().getName() + "在执行了");
});
executorService.shutdown();
}
}
1.2 线程状态介绍
线程对象在不同的时期有不同的状态，一共有6种状态
1.2.1 线程状态源码
public class Thread {
public enum State {
/* 新建 */
NEW ,
/* 可运行状态 */
RUNNABLE ,
/* 阻塞状态 */
BLOCKED ,
/* 无限等待状态 */
WAITING ,
/* 计时等待 */
TIMED_WAITING ,
/* 终止 */
TERMINATED;
}
// 获取当前线程的状态
public State getState() {
return jdk.internal.misc.VM.toThreadState(threadStatus);
}
}
1.2.2 线程状态含义
| 线程状态 | 具体含义 |
|---|---|
| NEW | 一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。 |
| RUNNABLE | 当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。 |
| BLOCKED | 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。 |
| WAITING | 一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。 |
| TIMED_WAITING | 一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。 |
| TERMINATED | 一个完全运行完成的线程的状态。也称之为终止状态、结束状态 |
1.2.3 线程状态转换图
2 原子性
2.1 volatile关键字
1. 问题 :
当A线程修改了共享数据时，B线程没有及时获取到最新的值，如果还在使用原先的值，就会出现问题
-
堆内存是唯一的，每一个线程都有自己的线程栈。
-
每一个线程在使用堆里面变量的时候，都会先拷贝一份到变量的副本中。
-
在线程中，每一次使用是从变量的副本中获取的。
2. Volatile解决 : 强制线程每次在使用的时候，都会看一下共享区域最新的值,代码示例如下：
package com.syh;
public class Money{
public static volatile int money = 1000;
}
package com.syh;
public class MyThread1 extends Thread{
@Override
public void run() {
Money.money -= 100;
System.out.println("李默然：" + Money.money);
}
}
package com.syh;
public class MyThread2 extends Thread{
@Override
public void run() {
System.out.println("林北辰：" + Money.money);
}
}
package com.syh;
public class Test {
public static void main(String[] args) {
MyThread1 t1 = new MyThread1();
t1.start();
MyThread2 t2 = new MyThread2();
t2.start();
}
}
2.2 synchronized解决
1. synchronized解决步骤 :
-
线程获得锁
-
清空变量副本
-
拷贝共享变量最新的值到变量副本中
-
执行代码
-
将修改后变量副本中的值赋值给共享数据
-
释放锁
2. 代码实现 :
package com.syh;
public class Money{
public static Object lock = new Object();
public static int money = 1000;
}
package com.syh;
public class MyThread1 extends Thread{
@Override
public void run() {
synchronized (Money.lock){
Money.money -= 100;
System.out.println("李默然: " + Money.money);
}
}
}
package com.syh;
public class MyThread2 extends Thread{
@Override
public void run() {
synchronized (Money.lock){
System.out.println("林北辰：" + Money.money);
}
}
}
package com.syh;
public class Test {
public static void main(String[] args) {
MyThread1 t1 = new MyThread1();
t1.start();
MyThread2 t2 = new MyThread2();
t2.start();
}
}
2.3 原子性
原子性就是要么所有的操作都执行，要么所有的操作都不执行，多个操作是一个不可以分割的整体。
2.4 AtomicInteger类
java从JDK1.5开始提供了AtomicInteger类，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式，常用方法如下:
public AtomicInteger()： // 1.初始化一个默认值为0的原子型Integer
public AtomicInteger(int initialValue)： // 2.初始化一个指定值的原子型Integer
int get(): // 3.获取值
int getAndIncrement(): // 4.以原子方式将当前值加1，注意，这里返回的是自增前的值。
int incrementAndGet(): // 5.以原子方式将当前值加1，注意，这里返回的是自增后的值。
int addAndGet(int data): // 6.以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
int getAndSet(int value): // 7.以原子方式设置为newValue的值，并返回旧值。
代码实现 :
package com.syh;
import java.util.concurrent.atomic.AtomicInteger;
public class MyAtom {
public static void main(String[] args) {
AtomicInteger ac = new AtomicInteger();
System.out.println(ac);
AtomicInteger ac2 = new AtomicInteger(10);
System.out.println(ac2);
}
}
2.5 悲观锁和乐观锁
synchronized和CAS的区别是什么?
1. 相同点
在多线程情况下，都可以保证共享数据的安全性。
2.不同点
-
悲观锁：synchronized总是从最坏的角度出发，认为每次获取数据的时候，别人都有可能修改。所以在每次操作共享数据之前，都会上锁。
-
乐观锁：cas是从乐观的角度出发，假设每次获取数据别人都不会修改，所以不会上锁。只不过在修改共享数据的时候，会检查一下，别人有没有修改过这个数据。
![uni-app+vue3开发微信小程序使用本地图片渲染不出来报错[渲染层网络层错误]Failed to load local image resource](https://i-blog.csdnimg.cn/direct/356ce37ca6cf4afbabd205b1d0cfb70c.png)
