Java多线程编程
Java多线程编程
线程概念
线程概念：
一个线程就是一个 “执行流”. 每个线程之间都可以按照顺讯执行自己的代码. 多个线程之间 “同时” 执行 着多份代码
线程作用：
在多核CPU情况下，充分利用CPU资源；对于需要等待IO的任务，利用CPU资源
在创建，销毁，调度上相比进程更加轻量
进程和线程的区别：
进程是包含线程的，每个进程至少有一个线程存在，即主线程
进程和进程之间不共享内存空间，同一个进程的线程之间共享同一个内存空间
进程是系统分配资源的最小单位，线程是系统调度的最小单位
线程常用方法
Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关 联
构造方法：
方法 | 说明 |
|---|---|
Thread() | 创建线程对象 |
Thread(Runnable target) | 使用 Runnable 对象创建线程对象 |
Thread(String name) | 创建线程对象，并命名 |
Thread(Runnable target, String name) | 使用 Runnable 对象创建线程对象，并命名 |
Thread(ThreadGroup group, Runnable target) | 线程可以被用来分组管理，分好的组即为线程组，这 个目前我们了解即可 |
属性方法：
属性 | 获取方法 |
|---|---|
ID | getId() |
名称 | getName() |
状态 | getState() |
优先级 | getPriority() |
是否后台线程 | isDaemon() |
是否存活 | isAlive() |
是否被中断 | isInterrupted() |
注：优先级高的线程理论上来说更容易被调度到；JVM会在一个进程的所有非后台线程结束后，才会结束运行
启动线程：
t.start();//调用 start 方法, 才真的在操作系统的底层创建出一个线程获取当前线程引用：
方法 | 说明 |
|---|---|
public static Thread currentThread(); | 返回当前线程对象的引用 |
休眠当前线程：
方法 | 说明 |
|---|---|
public static void sleep(long millis) throws InterruptedException | 休眠当前线程 millis 毫秒 |
public static void sleep(long millis, int nanos) throws InterruptedException | 可以更高精度的休眠 |
线程创建
继承Thread类：
public class ThreadDemo extends Thread {
@Override
public void run() {
System.out.println("hello world");
}
public static void main(String[] args) {
ThreadDemo t = new ThreadDemo();
t.start();//创建线程+调用run()
System.out.println("nihao");
}
}实现Runnable接口：
public class Thread2 implements Runnable{
@Override
public void run() {
System.out.println("hello world");
}
public static void main(String[] args) {
Thread t = new Thread(new Thread2());
t.start();//创建线程+调用run()
System.out.println("nihao");
}
}匿名内部类Thread子类：
public static void main(String[] args) {
Thread t = new Thread(){
@Override
public void run() {
System.out.println("hello world");
}
};
t.start();
System.out.println("nihao");
}匿名内部类Runnable子类：
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello world");
}
});
t.start();
System.out.println("nihao");
}lambda表示式创建Runnable子类：
public static void main(String[] args) {
Thread t = new Thread(() -> {
System.out.println("hello world");
});
t.start();
System.out.println("nihao");
}线程优先级
Java采用的是抢占式调度方式，优先级越高的线程，优先使用CPU资源
我们希望CPU花费更多的时间去处理更重要的任务，而不太重要的任务，则可以先让出一部分资源。
线程的优先级一般分为以下三种：
- MIN_PRIORITY 最低优先级
- MAX_PRIORITY 最高优先级
- NOM_PRIORITY 常规优先级
public static void main(String[] args) {
Thread t = new Thread(() -> {
System.out.println("线程开始运行！");
});
t.start();
t.setPriority(Thread.MIN_PRIORITY); //通过使用setPriority方法来设定优先级
}终止线程
- 通过共享的标记来进行沟通
public class ThreadDemo {
public static volatile boolean isQuit = false;//volatile保证内存可见性
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
while (!isQuit) {//自动捕获‘final’属性的变量
System.out.println(Thread.currentThread().getName()
+ ": hello worold!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()
+ ": out of while");
}, "李四");
System.out.println(Thread.currentThread().getName()
+ ": start。");
thread.start();
Thread.sleep(10 * 1000);
System.out.println(Thread.currentThread().getName()
+ ": down！");
isQuit = true;
}
}- 调用 interrupt() 方法来通知
使用 Thread.interrupted() 或者 Thread.currentThread().isInterrupted() 代替自定义标志位
方法 | 说明 |
|---|---|
public void interrupt() | 中断对象关联的线程，如果线程正在阻塞，则以异常方式通知， 否则设置标志位 |
public static boolean interrupted() | 判断当前线程的中断标志位是否设置，调用后清除标志位 |
public boolean isInterrupted() | 判断对象关联的线程的标志位是否设置，调用后不清除标志位 |
public class test1 {
static class MyRunnable implements Runnable {
@Override
public void run() {
while(!Thread.interrupted()){
System.out.println("working---");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
//选择处理方式
break;
}
}
}
}
public static void main(String[] args) {
MyRunnable mr = new MyRunnable();
Thread t = new Thread(mr);
t.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread interrupted");
t.interrupt();
}
}thread 收到通知的方式有两种：
- 如果线程因为调用 wait/join/sleep 等方法而阻塞挂起，则以 InterruptedException 异常的形式通 知，清除中断标志；当出现 InterruptedException 的时候, 要不要结束线程取决于 catch 中代码的写法. 可以选择忽略这个异常, 也可以跳出循环结束线程
- 如果线程正在工作，则只是内部的一个中断标志被设置；Thread.interrupted() 判断当前线程的中断标志被设置，清除中断标志Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设置，不清除中断标志
等待线程
有时需要等待一个线程完成它的工作后，才能进行自己的下一步工作。
方法 | 说明 |
|---|---|
public void join() | 等待线程结束 |
public void join(long millis) | 等待线程结束，最多等 millis 毫秒 |
public void join(long millis, int nanos) | 同理，但可以更高精度 |
public class test2 {
public static void main(String[] args) throws InterruptedException {
Runnable r = () -> {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+" working...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "work finish");
};
Thread t1 = new Thread(r, "zhangsan");
Thread t2 = new Thread(r, "lisi");
t1.start();
t2.start();
t1.join();
t2.join();
}
}线程状态
线程的状态是一个枚举类型 Thread.State
public class ThreadState {
public static void main(String[] args) {
for (Thread.State state : Thread.State.values()) {
System.out.println(state);
}
}
}NEW: 安排了工作, 还未开始行动
RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
BLOCKED: 这几个都表示排队等着其他事情，被锁给阻塞住了
WAITING: 这几个都表示排队等着其他事情，被wait()给阻塞住了
TIMED_WAITING: 这几个都表示排队等着其他事情，被sleep()给阻塞住了
TERMINATED: 工作完成了状态转移图：
BLOCKED 表示等待获取锁 WAITING 和 TIMED_WAITING 表示等待其他线程发来通知 TIMED_WAITING 线程在等待唤醒，但设置了时限 WAITING 线程在无限等待唤醒
相关函数：
yield();//让出cpu，yield 不改变线程的状态, 但是会重新去排队
isAlive();//判断线程的存活状态线程安全
多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线 程安全的。
修改共享数据：
多个线程针对 counter.count 变量进行修改，此时这个 counter.count 是一个多个线程都能访问到的 “共享数据”
原子性：
原子性表示一个资源在同一时间段下只有一个访问资源者进行操作
有时也把这个现象叫做同步互斥，表示操作是互相排斥的
一条 java 语句不一定是原子的，因为语句不一定包含的可能不只是一条指令
数据自增1底层操作步骤：
- 从内存把数据读到 CPU
- 进行数据更新
- 把数据写回到 CPU
synchronized
synchronized 是一个互斥锁, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到 同一个对象 synchronized 就会阻塞等待。
synchronized用的锁是存在Java对象头里的，synchronized的底层是使用操作系统的mutex lock实现的。
synchronized上锁是需要传入对象的，当对象不同时，获取到的是不同的锁，因此并不能保证自增操作的原子性。
public class SynchronizedDemo {
public void method() {
synchronized (this) {//锁当前对象
}
}
}synchronized关键字也可以作用于方法上，调用此方法时也会获取锁：
private static int value = 0;
private static synchronized void add(){
value++;
}如果是静态方法，就是使用的类锁，而如果是普通成员方法，就是使用的对象锁。通过灵活的使用synchronized就能很好地解决线程安全的问题。
synchronized 的工作过程:
- 获得互斥锁
- 从主内存拷贝变量的最新副本到工作的内存
- 执行代码
- 将更改后的共享变量的值刷新到主内存
- 释放互斥锁
synchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题
在可重入锁的内部, 包含了 “线程持有者” 和 “计数器” 两个信息：
如果某个线程加锁的时候, 发现锁已经被人占用, 但是恰好占用的正是自己, 那么仍然可以继续获取 到锁, 并让计数器自增
解锁的时候计数器递减为 0 的时候, 才真正释放锁. (才能被别的线程获取到)
volatile
volatile 修饰的变量, 能够保证 “内存可见性”
直接访问工作内存(实际是 CPU 的寄存器或者 CPU 的缓存), 速度非常快, 但是可能出现数据不一致的情况。变量加上 volatile 关键字修饰, 强制读写内存，速度是慢了, 但是数据变的更准确了。
代码在写入 volatile 修饰的变量的时候：
- 改变线程工作内存中volatile变量副本的值
- 将改变后的副本的值从工作内存刷新到主内存
代码在读取 volatile 修饰的变量的时候：
- 从主内存中读取volatile变量的最新值到线程的工作内存中
- 从工作内存中读取volatile变量的副本
wait和notify方法
wait()、notify()以及notifyAll()是需要配合synchronized来使用的（实际上锁就是依附于对象存在的，每个对象都应该有针对于锁的一些操作）。
对象的wait()方法会暂时使得此线程进入等待状态，同时会释放当前代码块持有的锁，这时其他线程可以获取到此对象的锁。
当其他线程调用对象的notify()方法后，会唤醒刚才变成等待状态的线程（必须是在持有锁（同步代码块内部）的情况下使用，否则会抛出异常）。
notifyAll其实和notify一样，也是用于唤醒，但是前者是唤醒所有调用wait()后处于等待的线程，而后者是看运气随机选择一个。
public static void main(String[] args) throws InterruptedException {
Object o1 = new Object();
Thread t1 = new Thread(() -> {
synchronized (o1){
try {
System.out.println("开始等待");
o1.wait(); //进入等待状态并释放锁
System.out.println("等待结束！");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread t2 = new Thread(() -> {
synchronized (o1){
System.out.println("开始唤醒！");
o1.notify(); //唤醒处于等待状态的线程
for (int i = 0; i < 50; i++) {
System.out.println(i);
}
//唤醒后依然需要等待这里的锁释放之前等待的线程才能继续
}
});
t1.start();
Thread.sleep(1000);
t2.start();
}ThreadLocal的使用
每个线程都有一个自己的工作内存，可以使用ThreadLocal类，来创建工作内存中的变量，它将我们的变量值存储在内部（只能存储一个变量），不同的线程访问到ThreadLocal对象时，都只能获取到当前线程所属的变量。
public static void main(String[] args) throws InterruptedException {
ThreadLocal<String> local = new ThreadLocal<>(); //注意这是一个泛型类，存储类型为我们要存放的变量类型
Thread t1 = new Thread(() -> {
local.set("lbwnb"); //将变量的值给予ThreadLocal
System.out.println("变量值已设定！");
System.out.println(local.get()); //尝试获取ThreadLocal中存放的变量
});
Thread t2 = new Thread(() -> {
System.out.println(local.get()); //尝试获取ThreadLocal中存放的变量
});
t1.start();
Thread.sleep(3000); //间隔三秒
t2.start();
}线程中创建的子线程，无法获得父线程工作内存中的变量，使用InheritableThreadLocal来解决：
public static void main(String[] args) {
ThreadLocal<String> local = new InheritableThreadLocal<>();
Thread t = new Thread(() -> {
local.set("lbwnb");
new Thread(() -> {
System.out.println(local.get());
}).start();
});
t.start();
}在InheritableThreadLocal存放的内容，会自动向子线程传递。
标准库线程安全类
Java 标准库中很多都是线程不安全的. 这些类可能会涉及到多线程修改共享数据, 又没有任何加锁措施:
- ArrayList
- LinkedList
- HashMap
- TreeMap
- HashSet
- TreeSet
- StringBuilder
使用了一些锁机制来保证线程安全的类：
- Vector (不推荐使用)
- HashTable (不推荐使用)
- ConcurrentHashMap
- StringBuffer
不涉及 “修改”, 仍然是线程安全的：
- String (() -> { local.set(“lbwnb”); new Thread(() -> { System.out.println(local.get()); }).start(); }); t.start(); }
在InheritableThreadLocal存放的内容，会自动向子线程传递。
## 标准库线程安全类
Java 标准库中很多都是线程不安全的. 这些类可能会涉及到多线程修改共享数据, 又没有任何加锁措施:
1. ArrayList
2. LinkedList
3. HashMap
4. TreeMap
5. HashSet
6. TreeSet
7. StringBuilder
使用了一些锁机制来保证线程安全的类：
1. Vector (不推荐使用)
2. HashTable (不推荐使用)
3. ConcurrentHashMap
4. StringBuffer
不涉及 "修改", 仍然是线程安全的：
1. String 腾讯云开发者
