JAVA并发编程（一）

1.1JAVA线程API

在这里插入图片描述

1.1.1currentThread

package com.lisus2000.thread;

/**
* 当前线程
*
*/
public class Test07 extends Thread {

   public Test07() {
       System.out.println("new Test07()......" + Thread.currentThread().getName());
   }

   @Override
   public void run() {
       System.out.println("线程执行......" + Thread.currentThread().getName());
   }

   public static void main(String[] args) {
       System.out.println("main方法........." + Thread.currentThread().getName());

       Test07 test07 = new Test07();
       test07.start();
   }
}

1.1.2join

package com.lisus.thread;

import com.bjpowernode.util.ThreadUtils;

public class Test10 {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("main线程执行....start.....");
        Thread t=new Thread(()->{
           for (int i=0;i<20;i++){
               System.out.println("VIP线程来了...");
               ThreadUtils.sleep(1);
           }
        });
        t.start();

        //线程加入，线程插队，线程合并
        //当t执行完成，才会把cpu执行权交出来，main线程才会继续往下执行，如果t没有执行完，main就不会往下执行，相当于t线程强行插队了
        //join方法就是等待这个线程执行结束
        //常用于 一个线程需要另一个线程的结果时
        //thread.join();
        //main线程
        for (int i=0;i<20;i++){
            System.out.println("main线程执行："+i);
            if(i==10){
                t.join();//强行插队
            }
        }
        System.out.println("main线程执行...end..." + Thread.currentThread().getName());
    }
}

package com.lisus.thread;

/**
 * 线程join
 *
 */
public class Test11 {

    private static int sum = 0;

    public static void main(String[] args) throws InterruptedException {

        System.out.println(Thread.currentThread().getName()+"线程执行...start...");

        Thread t = new Thread( () -> {
            for (int i = 0; i < 20; i++) {
                sum += i;
            }
        });
        t.start();

        t.join();

        System.out.println(Thread.currentThread().getName()+"线程执行...end..., sum = " + sum);
    }
}

1.1.3yield

package com.lisus.thread;

public class Test12 {
    public static void main(String[] args) {
        System.out.println("main线程执行...start..." + Thread.currentThread().getName());
        Thread thread=new Thread(()->{
           long start=System.currentTimeMillis();
           long res=0;
           for (long i=1;i<=1000000;i++){
               res+=i;
               Thread.yield();//让步，放弃CPU执行权
           }
            long end = System.currentTimeMillis();
            System.out.println("运算时间：" + (end - start) + " 结果：" + res);
        });
        thread.start();
        System.out.println("main线程执行...end..." + Thread.currentThread().getName());
    }
}

1.1.4interrupt

package com.lisus.thread;

public class Test14 {
    public static void main(String[] args) throws InterruptedException {
//         Thread t1 = new Thread( () -> {
//            for (int i = 0; i < 10000; i++) {
//                //通过中断状态可以优雅地把一个正在运行的线程停下来
//                if (Thread.currentThread().isInterrupted()) {
//                    break;
//                    //return;
//                }
//                System.out.println(Thread.currentThread().getName() + "......" + Thread.currentThread().isInterrupted()+ i);
//            }
//        });
//        t1.start();

        Thread t2 = new Thread( () -> {
            //ThreadUtils.sleep(15);
            //for (int i = 0; i < 10; i++) {
            for (;;) {
                System.out.println("中断睡眠..." + Thread.currentThread().isInterrupted());
            }
        });
        t2.start();

        //main线程
        for (int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName() + "......" + i);
        }

        t2.join();
        //t1.interrupt();//中断一个正在运行的线程，但是实际上并没有真正地中断，只是标记了该线程是中断状态

        t2.interrupt();//中断一个正在休眠的线程
    }
}

1.2Java main 线程执行结束后，，在在 main 线程中创建的子线程是否也自动结束？

线程可分为：用户线程(user thread) 和 守护线程(daemon thread)；
守护线程指在后台运行的线程，也称为后台线程，用于提供后台服务；
Java 创建的线程默认是用户线程，如果要创建守护线程，需要单独设置；
t1.setDaemon(true);
用户线程 和 守护线程的区别：
在一个应用中只要有任何一个用户线程还在运行，应用程序就不会退出，反之就会退出；
一个程序（Java 程序，java web 程序，tomcat）至少得有一个用户线程；
白话：守护线程要寄生在用户线程下生存，没有用户线程了，守护线程也就死了；
Thread 类与守护线程有关的方法声明如下：
public final void setDaemon(boolean on)
//若 on 为 true，则设置为守护线程，必须在启动线程前调用；
GC 垃圾回收线程：就是一个经典的守护线程；
守护线程：清理数据、监控、告警；
public synchronized void start()
public void run()
public static native Thread currentThread();
public static native void sleep(long millis) throws InterruptedException;
public final void setDaemon(boolean on)
public final void join() throws InterruptedException
public static native void yield();
public ClassLoader getContextClassLoader() / set
public void interrupt()；
public final int getPriority() / set

1.3Object 类的 wait/notify/notifyAll

1.3.1wait

1.wait方法的作用是使当前线程等待，当前线程必须拥有些此对象（调用wait方法的那个对象）的监视器（锁）才能调用wait方未能，否则抛出IllegalMonitorStateException异常，当调用wait方法后线程会释放此监视器的所有权（锁）并等待

2.wait方法调用后，直到另一个线程对此对象（调用wait方法的那个对象明）调用notify()方法或notifyAll方法，通知和唤醒在些对象上等待的线程，然后线程等待直到它可以重新获得监视器的所有权（锁）并恢复执行。

3.wait()方法的行为和执行调用 wait(0)一样，（0 表示如果不通知，则无限等待）

4.有可能被线程中断和虚假唤醒，应始终在循环中使用 while 进行判断：

示例1：

package com.lisus.object;

import com.bjpowernode.util.ThreadUtils;

public class Test01 {
    private static Object MONITOR = new Object();

    private static Test01 TEST_01 = new Test01();

    private static int i = 0;

    public static void main(String[] args) throws InterruptedException {
        System.out.println("main方法start.....");
        new Thread(()->{
            ThreadUtils.sleep(2);
            System.out.println("开始通知");
            synchronized (TEST_01){
                TEST_01.notify();
                i=1;
                System.out.println("通知结束");
            }
        }).start();

        //想让main线程在此处等待
        synchronized (TEST_01){
            while (i==0){
                TEST_01.wait();//等待并释放
            }
        }
        System.out.println("main方法end......" + Thread.currentThread().getName());
    }
}

5.如果任何线程在当前线程等待通知之前或期间中断了当前线程，抛 InterruptedException异常，并清除当前线程的中断状态；

package com.lisus.object;

import com.bjpowernode.util.ThreadUtils;

public class Test02 {
   private static final Object MONITOR = new Object();

   private static Test01 TEST_01 = new Test01();

   private static int i = 0;

   public static void main(String[] args) {
       System.out.println("main方法执行开始......" + Thread.currentThread().getName());
       Thread t=new Thread(()->{
          synchronized (MONITOR){
              while (i==0){
                  try {
                      MONITOR.wait();
                      System.out.println(1111);

                  }catch (InterruptedException e){
                      e.printStackTrace();
                  }
              }
              System.out.println(Thread.currentThread().isInterrupted());
          }
       });
       t.start();
       ThreadUtils.sleep(3);
       t.interrupt();//中断
       System.out.println("main方法执行结束......" + Thread.currentThread().getName());
   }
}

1.3.2notify

1、notify 方法唤醒在此对象（调用 wait 方法的那个对象）上等待的单个线程，如果在此对象上有多个线程正在等待，则选择其中一个线程唤醒，选择是任意随机的，并且由实现决定；

2、当前线程必须拥有此对象（调用 wait 方法的那个对象）的监视器（锁）才能调用 notify方法，否则抛IllegalMonitorStateException 异常；

3、被唤醒的线程将无法继续，直到当前线程放弃对该对象的锁，被唤醒的线程将与此对象上的任何其他线程进行锁竞争，拿到锁才能继续执行；

4、notify 方法只有拿到此对象（调用 wait 方法的那个对象）监视器的锁之后才能调用，线程通过以下三种方式之一拿到对象监视器的锁：

（1）通过执行该对象的同步实例方法；
（2）通过执行同步对象的同步语句块；
（3）对于 Class 类型的对象，通过执行该类的同步静态方法；

1.4 wait 、notify 、notifyAll 的应用场影

经典的生产者-消费者模式；
生产者生产数据到缓冲区中，消费者从缓冲区中取数据；
如果缓冲区已经满了，则生产者线程阻塞等待；
如果缓冲区为空，那么消费者线程阻塞等待；

Java 实现生产者消费者模式的几种常用方法：
1、wait() / notifyAll()方法
2、await() / signal()方法；
3、信号量 Semaphore 方法；
4、阻塞队列 BlockingQueue 方法；
5、管道 PipedWriter/PipedReader 方法；
6、无锁队列 Disruptor 框架方法；
7、分布式下的消息队列（分布式下的消息队列也是生产者-消费者模式）；
wait() / notify()方法
1、当生产者向缓冲区放入一个数据时，向其他等待的消费线程发出可消费的通知，当缓冲区
满了，生产者停止生产并等待；
2、当消费者从缓冲区取出一个数据时，向其他等待的生产线程发出可生产的通知，当缓冲区
空了，消费者停止消费并等待；

示例

AbstractConsumer类

package com.lisus.waitnotify;

public abstract class AbstractConsumer implements Runnable{
    /**
     * 模板方法
     */
    @Override
    public final void run() {
        while (true){
            //消费
            consume();
            try{
                Thread.sleep(10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    protected abstract void consume();
}

AbstractProducer类

package com.lisus.waitnotify;

/**
 * 生产者
 */
public abstract class AbstractProducer implements Runnable{
    @Override
    public void run() {
        while (true){
            //生产
            produce();
            try {
                Thread.sleep(10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    protected abstract void produce();
}

DataBuffer类

package com.lisus.waitnotify;

import java.util.ArrayList;
import java.util.List;

/**
 * 数据缓冲区
 */
public class DataBuffer {
    private  final List<Integer> dataBuffer=new ArrayList<>();
    protected static final int MAX_SIZE=1024;

    public List<Integer> getDataBuffer(){
        return dataBuffer;
    }
}

Consumer类

package com.lisus.waitnotify;

public class Consumer extends AbstractConsumer{
    private DataBuffer dataBuffer;

    /**
     * 通过构造方法把dataBuffer初始化
     *
     * @param dataBuffer
     */
    public Consumer(DataBuffer dataBuffer) {
        this.dataBuffer = dataBuffer;
    }
    @Override
    protected void consume() {

        synchronized (dataBuffer.getDataBuffer()) {
            //如果缓存区是空的，就需要等待
            while (dataBuffer.getDataBuffer().isEmpty()) {
                try {
                    System.out.println("缓存区空了，消费者阻塞等待......");
                    dataBuffer.getDataBuffer().wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //消费数据
            Integer number = dataBuffer.getDataBuffer().remove(0);
            System.out.println("消费者消费了一条数据......" + number);

            //通知一下生产者，可以继续生产
            dataBuffer.getDataBuffer().notifyAll();
        }
    }
}

Producer类

package com.lisus.waitnotify;

import java.util.concurrent.atomic.AtomicInteger;

public class Producer extends AbstractProducer{
    private DataBuffer dataBuffer;
    private AtomicInteger atomicInteger=new AtomicInteger();

    /**
     * 通过构造方法把dataBuffer初始化
     * @param dataBuffer
     */
    public Producer(DataBuffer dataBuffer){
        this.dataBuffer=dataBuffer;
    }

    @Override
    protected void produce() {
        synchronized (dataBuffer.getDataBuffer()){
            //如果缓存满了，我就需要等待
            while (dataBuffer.getDataBuffer().size() == DataBuffer.MAX_SIZE){
                try{
                    System.out.println("缓存区满了，生产者阻塞等待......");
                    dataBuffer.getDataBuffer().wait();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            //生产数据
            dataBuffer.getDataBuffer().add(atomicInteger.getAndIncrement());
            System.out.println("生产者生产了一条数据......");

            //生产数据了，可以通知消费者来消费
            dataBuffer.getDataBuffer().notifyAll();
        }
    }
}

Test类

package com.lisus.waitnotify;

/**
 * 测试
 */
public class Test {
    public static void main(String[] args) {
        DataBuffer dataBuffer=new DataBuffer();
        for (int i=0;i<16;i++){
            Producer producer=new Producer(dataBuffer);
            Thread thread=new Thread(producer);
            thread.start();
        }

        for (int i = 0; i < 16; i++) {
            Consumer consumer = new Consumer(dataBuffer);
            Thread thread1 = new Thread(consumer);
            thread1.start();
        }
    }
}

运行结果

在这里插入图片描述

1.5LockSupport 工具类

1.5.1介绍

LockSupport 是 java.util.concurrent.locks 包下的一个类，是用来创建锁和其他同步类的基本线程阻塞工具类，它里面的方法都是静态方法；
我们前面介绍了等待/唤醒机制 wait/notify，那么这个 LockSupport 可以说是它的改良版；

LockSupport 主要就是用 park(等待)和 unpark(唤醒)方法来实现等待唤醒；

park 方法是将当前 Thread 阻塞，而 unpark 方法将指定线程 Thread 唤醒；

在这里插入图片描述

纳秒是多久：1 秒等于 1000 毫秒，等于 100 万微秒，等于 10 亿纳秒；
与 Object 类的 wait/notify 机制相比，park/unpark 的特点：
1、LockSupport 不需要在同步块中使用；

2、LockSupport 以 thread 为操作对象更符合阻塞线程的直观定义；

3、LockSupport 操作更精准，可以精确地唤醒某一个线程（notify 随机唤醒一个线程，
notifyAll 唤醒所有等待的线程）；

4、LockSupport 先 unpark 再 park 也不会报错，先 unpark 相当于(先吃药不晕车，先吃解
药不中毒)，而 notify 先唤醒再等待的话，都会导致线程无法被唤醒；

5、LockSupport 中断 park 不会抛出 InterruptedException 异常，需要在 park 之后自行判
断中断状态做额外的处理；

1.5.2LockSupport 底层实现

LockSupport 底层是通过 java 的 Unsafe 类的 park 和 unpark 方法直接调用底层操作系统来
完成对线程的阻塞；

LockSupport 的原理就是使用了一种 permit（许可证）的概念来实现等待唤醒功能，每个线
程都有一个许可证，许可证只有两个值，一个是 0，一个是 1；
默认许可证的值是 0，表示没有许可证，就会被阻塞；

调用 unpark 方法就把 permit 的值改为 1，相当于发放一个许可证；
调用 park 方法就把 permit 的值改为 0，相当于收回许可证；

每调用一次 unpark 方法，permit 就会变成 1，每调一次 park 方法，就会消耗掉一个许可证，
permit 就变成 0；

每个线程都有一个 permit，permit 最多也就一个，多次调用 unpark 也不会累加；
根据是否有 permit 来判断是否要阻塞线程，所以先 unpark 再 park 也可以，跟顺序无关，
只看是否有 permit；（0 阻塞，1 不阻塞）

如果先 unpark 了两次（值 1），再 park 两次（第一次 1 可以执行，第二次 0,阻塞），那么
线程还是会被阻塞，因为 permit 不会累加，unpark 两次，permit 的值还是 1，第一次 park
的时变成 0 了，所以第二次 park 就会阻塞线程；

park 线程不能用 notify 来唤醒，wait 线程也不能用 unpark 来唤醒；

1.5.3示例

package com.lisus.lock;

import com.bjpowernode.util.ThreadUtils;

import java.util.concurrent.locks.LockSupport;

public class Test01 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "开始执行.......");
        Thread mainThread=Thread.currentThread();

        new Thread(()->{
            ThreadUtils.sleep(3);
            LockSupport.unpark(mainThread);//3秒之后唤醒主线程
        }).start();
        LockSupport.park();//当前线程阻塞（main线程） Object wait()
        System.out.println(Thread.currentThread().getName() + "结束执行.......");
    }
}

在这里插入图片描述

package com.lisus.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class Test02 {
    public static void main(String[] args) {
        System.out.println(TimeUnit.SECONDS.toNanos(1));

        Thread t1 = new Thread(() -> {
            System.out.println("线程" + Thread.currentThread().getName() + "进来了");
            //LockSupport.park(); // 等待
            //LockSupport.parkNanos(1_000_000_000); // 等待1秒
            //LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(3));  //Thread.sleep(3000L)

            //注意这里的时间需要使用系统时间加上需要等待的时间
            LockSupport.parkUntil(System.currentTimeMillis() + 3000);

            System.out.println("线程" + Thread.currentThread().getName() + "被唤醒");
        }, "t1");
        t1.start();

        Thread t2 = new Thread(() -> {
            System.out.println("线程" + Thread.currentThread().getName() + "执行唤醒");
            LockSupport.unpark(t1); // 唤醒t1线程
        }, "t2");
        t2.start();
    }
}

在这里插入图片描述
`

package com.lisus.lock;

import com.bjpowernode.util.ThreadUtils;

import java.util.concurrent.locks.LockSupport;

public class Test03 {
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            ThreadUtils.sleep(3);
            System.out.println("线程" + Thread.currentThread().getName() + "进来了");

            LockSupport.park();//等待  （许可证 变为 0），是否需要阻塞就看许可证是0还是1，是0才阻塞，是1就不需要阻塞
            System.out.println("第一次park");

            LockSupport.park(); // 等待  （许可证 变为 0）
            System.out.println("第二次park");


            System.out.println("线程" + Thread.currentThread().getName() + "被唤醒");
        },"t1");
        t1.start();

        Thread t2 = new Thread(() -> {
            System.out.println("线程" + Thread.currentThread().getName() + "执行唤醒");
            LockSupport.unpark(t1); // 唤醒t1线程 （许可证 变为 1 ，许可证默认0，也相当于许可证初始化是0）
            LockSupport.unpark(t1); // 唤醒t1线程
            LockSupport.unpark(t1); // 唤醒t1线程
            LockSupport.unpark(t1); // 唤醒t1线程
            LockSupport.unpark(t1); // 唤醒t1线程
        }, "t2");
        t2.start();
    }
}

在这里插入图片描述

package com.lisus.lock;

import com.bjpowernode.util.ThreadUtils;

import java.util.concurrent.locks.LockSupport;

public class Test05 {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            System.out.println(Thread.currentThread().getName() + " 开始执行......");
            LockSupport.park();
            System.out.println(Thread.currentThread().isInterrupted()); //中断状态

            System.out.println(Thread.currentThread().getName() + " 执行结束.....");
        },"t1线程");
        t.start();

        ThreadUtils.sleep(2);

        System.out.println("main：对t线程进行中断！");
        t.interrupt(); //对t线程做一个中断
        //LockSupport.unpark(t);
        System.out.println("main：执行结束！");
    }
}

在这里插入图片描述

1.6线程的状态及转换

在这里插入图片描述

java 线程定义了 6 种状态，在任何时刻，有且只能处于其中某一种状态；
1、新建（New）：线程创建后但还没有启动就处于这种状态；

2、运行（Runnable）：运行状态包括操作系统线程状态中的 Ready 和 Running，也就是处
于该状态的线程有可能正在执行，也有可能正在等待着操作系统为它分配执行时间；

（注：操作系统线程 5 种状态：初始状态、可运行状态、运行状态、阻塞状态、终止状态）
3、无限期等待（Waiting）：处于这种状态的线程不会被分配处理器执行时间，它们要等待
被其他线程唤醒；

4、超时等待（Timed Waiting）：处于这种状态的线程也不会被分配处理器执行时间，不过
它不需要等待其他线程唤醒，在一定时间之后它们会由系统自动唤醒；

5、阻塞（Blocked）：表示线程被阻塞了，在程序进入同步代码区域的时候，线程将进入这
种阻塞状态；
“阻塞状态”与“等待状态”的区别在于:
“阻塞状态”在等待着获取到一个排它锁，当获取到锁的时候就不会阻塞；
“等待状态”则是在等待（可能是有限时间等待或者是永久等待），直到等待时间超时或者有
另一个线程来唤醒，才不会等待；

6、终止（Terminated）：已终止的线程状态，表示线程已经结束执行；
上述 6 种状态在遇到特定事件发生的时候将会互相转换；
阻塞状态是线程阻塞在进入 synchronized 关键字修饰的方法或代码块（获取锁）时的状态，
没有获取到锁进入 blocked 状态；

但是阻塞在 java.util.concurrent 包中 Lock 接口的线程状态却是 Waiting 等待状态，因为
java.util.concurrent包中Lock接口对于阻塞的实现均使用了LockSupport类中的相关方法；

示例

package com.lisus.state;

public class Test01 {
    public static void main(String[] args) {
        Thread t1=new Thread("t1线程");
        System.out.println(t1.getName()+":"+t1.getState());
    }
}

在这里插入图片描述

package com.lisus.state;

import com.bjpowernode.util.ThreadUtils;

public class Test02 {
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"运行");

        },"t1线程");
        t1.start();
        ThreadUtils.sleep(2);
        System.out.println(t1.getName()+":"+t1.getState());
    }
}

在这里插入图片描述

package com.lisus.state;

import com.bjpowernode.util.ThreadUtils;

public class Test03 {
    public static void main(String[] args) {
        //RUNNABLE （包括 “就绪” 和 “运行” 两种状态）
        Thread t=new Thread(()->{
           while (true){
               //Thread.yield();
               //System.out.println(Thread.currentThread().getName() + ": " + Thread.currentThread().getState());
           }
        },"t线程");
        t.start();
        ThreadUtils.sleep(3);
        System.out.println(t.getName()+":"+t.getState());
    }
}

在这里插入图片描述

package com.lisus.state;

import com.bjpowernode.util.ThreadUtils;

/**
 * 线程6种状态
 *
 */
public class Test04 {

    private final static Object MONITOR = new Object();

    public static void main(String[] args) throws InterruptedException {

        Thread t = new Thread(() -> {
            synchronized (MONITOR) {
                try {
                    MONITOR.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t线程");
        t.start();

        //main线程休眠1秒
        ThreadUtils.sleep(1);
        System.out.println(t.getName() + ": " + t.getState());

        //-------------------------------------------------------

        //RUNNABLE （包括 “就绪” 和 “运行” 两种状态）
        Thread t1 = new Thread(() -> {
            while (true) {

            }
        }, "t1线程");
        t1.start();
        ThreadUtils.sleep(1);

        //WAITING 等待
        Thread t2 = new Thread(() -> {
            try {
                //等待t1线程完成
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t2线程");
        t2.start();
        ThreadUtils.sleep(1);
        System.out.println(t2.getName() + ": " + t2.getState());

        //-------------------------------------------------------

        /*Thread t3 = new Thread(() -> {
            LockSupport.park();
        }, "t3线程");
        t3.start();
        ThreadUtils.sleep(1);
        System.out.println(t3.getName() + ": " + t3.getState());*/
    }
}

在这里插入图片描述

package com.lisus.state;

import com.bjpowernode.util.ThreadUtils;
import sun.misc.ThreadGroupUtils;

public class Test05 {
    private final static Object MONITOR=new Object();

    public static void main(String[] args) {
        Thread t=new Thread(()->{
           synchronized (MONITOR){
               try{
                   MONITOR.wait();
                   while (true){

                   }
               }catch (InterruptedException e){
                   e.printStackTrace();
               }
           }
        },"t线程");
        t.start();
        ThreadUtils.sleep(1);
        System.out.println(t.getName()+":"+t.getState());

        //main线程
        synchronized (MONITOR) {
            MONITOR.notify();
        }
        ThreadUtils.sleep(1);
        System.out.println(t.getName() + ": " + t.getState()); //runnable

    }
}

在这里插入图片描述

package com.lisus.state;

import com.bjpowernode.util.ThreadUtils;

public class Test06 {
    private final static Object MONITOR=new Object();
    public static void main(String[] args) {
        //t线程:TIMED_WAITING
//        Thread t=new Thread(()->{
//            ThreadUtils.sleep(3);
//        },"t线程");
//        t.start();
//        ThreadUtils.sleep(1);
//        System.out.println(t.getName()+":"+t.getState());
        //t2线程: TIMED_WAITING
//        Thread t2 = new Thread(() -> {
//            synchronized (MONITOR) {
//                try {
//                    MONITOR.wait(3000L);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }
//        }, "t2线程");
//        t2.start();
//
//        ThreadUtils.sleep(1);
//        System.out.println(t2.getName() + ": " + t2.getState());
        Thread t3 = new Thread(() -> {
            while (true) {

            }
        }, "t3线程");
        t3.start();
        ThreadUtils.sleep(1);
        Thread t4 = new Thread(() -> {
            try {
                //等待t3线程完成
                t3.join(3000L);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t4线程");
        t4.start();
        ThreadUtils.sleep(1);
        System.out.println(t4.getName() + ": " + t4.getState());
    }
}

在这里插入图片描述

package com.lisus.state;

import com.bjpowernode.util.ThreadUtils;

public class Test07 {
    public static void main(String[] args) {
        //BLOCKED 阻塞
        /*Thread t1 = new Thread(() -> {
            synchronized (Test07.class) {
                ThreadUtils.sleep(300);
            }
        }, "t1线程");
        t1.start();

        Thread t2 = new Thread(() -> {
            synchronized (Test07.class) {
                ThreadUtils.sleep(300);
            }
        }, "t2线程");
        t2.start();
        ThreadUtils.sleep(1);
        System.out.println(t2.getName() + ": " + t2.getState());*/

        //------------------------------------------------------

        Test07 test07 = new Test07();

        Thread t3 = new Thread(() -> {
            test07.sync1();
        }, "t3线程");
        t3.start();
        System.out.println(t3.getName() + ": " + t3.getState());

        ThreadUtils.sleep(1);

        Thread t4 = new Thread(() -> {
            test07.sync2();
        }, "t4线程");
        t4.start();
        ThreadUtils.sleep(1);
        System.out.println(t4.getName() + ": " + t4.getState());
    }
    public synchronized void sync1() {
        System.out.println("正在执行sync方法...........");
        ThreadUtils.sleep(30);
    }

    public synchronized void sync2() {
        System.out.println("正在执行sync2方法...........");
        ThreadUtils.sleep(300);
    }
}

在这里插入图片描述

package com.lisus.state;

import com.bjpowernode.util.ThreadUtils;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 线程6种状态
 *
 * @author Cat老师，关注我，抖音搜索：java512
 */
public class Test08 {

    Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {

        Test08 test08 = new Test08();

        Thread t1 = new Thread(() -> test08.lock(), "t1线程");
        t1.start();
        ThreadUtils.sleep(1);
        System.out.println(t1.getName() + ": " + t1.getState());

        Thread t2 = new Thread(() -> test08.lock(), "t2线程");
        t2.start();
        ThreadUtils.sleep(1);
        System.out.println(t2.getName() + ": " + t2.getState()); // blocked ???
    }

    public void lock() {
        // 获取锁
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " get the lock");
            // 访问此锁保护的资源
            while (true) {

            }
        } finally {
            // 释放锁
            lock.unlock();
            System.out.println(Thread.currentThread().getName() + " release the lock");
        }
    }
}

cks.ReentrantLock;

/**

线程6种状态

@author Cat老师，关注我，抖音搜索：java512
*/
public class Test08 {

Lock lock = new ReentrantLock();

public static void main(String[] args) throws InterruptedException {

 Test08 test08 = new Test08();

 Thread t1 = new Thread(() -> test08.lock(), "t1线程");
 t1.start();
 ThreadUtils.sleep(1);
 System.out.println(t1.getName() + ": " + t1.getState());

 Thread t2 = new Thread(() -> test08.lock(), "t2线程");
 t2.start();
 ThreadUtils.sleep(1);
 System.out.println(t2.getName() + ": " + t2.getState()); // blocked ???

}

public void lock() {
// 获取锁
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + " get the lock");
// 访问此锁保护的资源
while (true) {

     }
 } finally {
     // 释放锁
     lock.unlock();
     System.out.println(Thread.currentThread().getName() + " release the lock");
 }

}
}


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/1abfdca657eb43b0bfa28793f3cfd6a1.png#pic_center)