目录

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);
         }
     }
}

 示例：

我们用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) {
 
      }
   }
}

public class SynchronizedDemo {
 public synchronized void methond() {
     }
}

public class SynchronizedDemo {
 public synchronized static void method() {
    }
}