多线程-线程状态和线程安全（加锁-synchronized 关键字）
目录
1.线程状态
示例：
1.1线程状态和状态转移的意义
2.线程安全
2.1观察线程不安全
2.2线程不安全的原因
3.synchronized 关键字 - 监视器锁 monitor lock
3.1synchronized 的特性
1. 互斥
2.可重⼊
应用示例：
3.2synchronized 使⽤⽰例
1. 修饰代码块: 明确指定锁哪个对象.
2.直接修饰普通⽅法: 锁的 SynchronizedDemo 对象
3.修饰静态⽅法: 锁的 SynchronizedDemo 类的对象
1.线程状态
在Java中，线程有几种不同的状态，可以通过Thread类的getState()方法获取线程的当前状态。
public class ThreadState {
public static void main(String[] args) {
for (Thread.State state : Thread.State.values()) {
System.out.println(state);
}
}
}
- NEW（新建）：新创建的线程尚未启动。
- RUNNABLE（可运行）：正在Java虚拟机中执行的线程，可能正在执行，也可能正在等待CPU时间片。
- BLOCKED（阻塞）：被阻塞并等待监视器锁定的线程。当线程试图进入一个同步代码块，而该块已经被其他线程持有时，该线程将进入阻塞状态。
- WAITING（等待）：无限期等待另一个线程执行特定操作的线程。线程可以通过调用Object类的wait()方法、Thread类的join()方法或LockSupport类的park()方法进入等待状态。
- TIMED_WAITING（计时等待）：在等待一段时间后自动恢复运行的线程。线程可以通过调用Thread类的sleep()方法、Object类的wait方法、Thread类的join方法进入计时等待状态。
- TERMINATED（终止）：已经执行完毕的线程，不再运行。
示例：
我们用getState()来获取线程的状态。
package 多线程;
public class ThreadDemo13 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
for (int i = 0; i < 5; i++) {
System.out.println("线程运行中");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
//启动之前状态是new状态
System.out.println(t.getState());
t.start();
System.out.println(t.getState());
t.join();
System.out.println(t.getState());
System.out.println("t线程结束");
}
}
我们查看结果一开始线程的状态是NEW，当我们t.start后线程的状态变成了RUNNABLE，之后线程开始运行。我们使用t.join(）提前结束线程。线程状态改变成了TERMINTED。
1.1线程状态和状态转移的意义
2.线程安全
线程安全是指在多线程环境下，多个线程同时访问共享资源时，不会出现数据不一致、竞态条件和死锁等问题。在并发编程中，如果多个线程同时访问共享的可变数据，可能会导致数据不一致的情况。例如，一个线程在读取一个共享变量的同时，另一个线程正在修改该变量，这就可能导致读取到的数据是脏数据（脏数据是指在并发环境下，一个线程正在修改某个共享变量的同时，另一个线程正在读取同一个变量的值，从而导致读取到的值不正确或者不符合预期。这种情况也被称为“读写冲突”。）或者不符合预期的结果。为了保证线程安全，需要采取相应的措施来避免这类问题。
2.1观察线程不安全
我们写一个程序来观察
// 此处定义⼀个 int 类型的变量
private static int count = 0;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
// 对 count 变量进⾏⾃增 5w 次
for (int i = 0; i < 50000; i++) {
count++;
}
});
Thread t2 = new Thread(() -> {
// 对 count 变量进⾏⾃增 5w 次
for (int i = 0; i < 50000; i++) {
count++;
}
});
t1.start();
t2.start();
// 如果没有这俩 join, 肯定不⾏的. 线程还没⾃增完, 就开始打印了. 很可能打印出来的 cou
t1.join();
t2.join();
// 预期结果应该是 10w
System.out.println("count: " + count);
}我们运行结果会发现每次运行的结果都是不一样的，这就是因为线程不安全所以我们的结果不正确。上⾯的线程不安全的代码中, 涉及到多个线程针对 count 变量进⾏修改. 此时这个 count 是⼀个多个线程都能访问到的 "共享数据"
2.2线程不安全的原因
1.根本原因：操作系统上的线程是“抢占式执行”“随机调度”=>线程之间执行的顺序带来了很多变数
2.代码结构：代码中多个线程，同时修改同一个变量。
一个线程修改一个变量，没事
多个线程读取同一个变量，没事
多个线程修改不同变量，没事
3.直接原因：上述多线程修改操作，本身不是“原子的”（原子性是指一个操作是不可中断的，在执行过程中不能被其他线程或事件打断，要么全部执行成功，要么全部不执行。如果一个操作具有原子性，那么多个线程同时执行这个操作时，不会出现数据不一致的问题。）
3.synchronized 关键字 - 监视器锁 monitor lock
synchronized是Java中用于实现同步的关键字，可以将代码块或方法声明为同步代码块或同步方法。在多线程环境下，使用synchronized可以确保同一时间只有一个线程能够访问共享资源，从而避免数据不一致的问题。
3.1synchronized 的特性
1. 互斥
2.可重⼊
synchronized 同步块对同⼀条线程来说是可重⼊的，不会出现⾃⼰把⾃⼰锁死的问题；
应用示例：
我们对count进行加锁
package 多线程;
public class ThreadDemo14 {
private static int count = 0;
public static void main(String[] args) throws InterruptedException {
//创建一个对象
Object locker = new Object();
Thread t1 = new Thread(()->{
for (int i = 0; i < 5000; i++) {
synchronized (locker) {//进程如{}就会加锁
count++;
}//出了{}就会解锁
}
});
Thread t2 = new Thread(()->{
for (int i = 0; i < 5000; i++) {
synchronized (locker) {
count++;
}
}
});
t1.start();
t2.start();
// 如果没有这俩 join, 肯定不⾏的. 线程还没⾃增完, 就开始打印了.
t1.join();
t2.join();
// 预期结果应该是 10w
System.out.println("count: " + count);
}
这样我们的结果就正确了。
3.2synchronized 使⽤⽰例
1. 修饰代码块: 明确指定锁哪个对象.
public class SynchronizedDemo {
private Object locker = new Object();
public void method() {
synchronized (locker) {
}
}
}
public class SynchronizedDemo {
public void method() {
synchronized (this) {
}
}
}2.直接修饰普通⽅法: 锁的 SynchronizedDemo 对象
public class SynchronizedDemo {
public synchronized void methond() {
}
}3.修饰静态⽅法: 锁的 SynchronizedDemo 类的对象
public class SynchronizedDemo {
public synchronized static void method() {
}
}希望大家多多支持!