JAVA并发编程（一）

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());}@Overridepublic 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{/*** 模板方法*/@Overridepublic 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{@Overridepublic 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;}@Overrideprotected 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;}@Overrideprotected 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)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/797858.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

vivado中移位寄存器的优化（二）

vivado中移位寄存器的优化（二）

移位寄存器优化用于改善移位寄存器单元&#xff08;SRLs&#xff09;与其他逻辑单元之间的负裕量路径的时序。如果存在对移位寄存器单元&#xff08;SRL16E或SRLC32E&#xff09;的时序违规&#xff0c;优化会从SRL寄存器链的开始或结束位置提取一个寄存器&#xff0c;并将其放…
阅读更多...
深入理解数据结构第三弹——二叉树（3）——二叉树的基本结构与操作

深入理解数据结构第三弹——二叉树（3）——二叉树的基本结构与操作

二叉树&#xff08;1&#xff09;&#xff1a;深入理解数据结构第一弹——二叉树&#xff08;1&#xff09;——堆-CSDN博客 二叉树&#xff08;2&#xff09;&#xff1a;深入理解数据结构第二弹——二叉树&#xff08;2&#xff09;——堆排序及其时间复杂度-CSDN博客 前言…
阅读更多...
面试：HashMap

面试：HashMap

目录 1、底层数据结构&#xff0c;1.7 与1.8有何不同? 2、为何要用红黑树&#xff0c;为何一上来不树化&#xff0c;树化阈值为何是8&#xff0c;何时会树化&#xff0c;何时会退化为链表? 3、索引如何计算? hashCode都有了&#xff0c;为何还要提供hash()方法?数组容量为…
阅读更多...
【Easy云盘 | 第十二篇】分享模块（获取分享信息、校验分享码、获取文件列表）

【Easy云盘 | 第十二篇】分享模块（获取分享信息、校验分享码、获取文件列表）

文章目录 4.4.4获取分享信息4.4.5校验分享码4.4.6获取文件列表 4.4.4获取分享信息 明天做 4.4.5校验分享码 明天做 4.4.6获取文件列表 明天做
阅读更多...
Vue3大事件项目1 登录注册

Vue3大事件项目1 登录注册

创建项目 引入 element-ui 组件库 登录&#xff1a;注册样式准备之后&#xff0c;配置校验规则&#xff08;4个条件&#xff1a;一数据、二规则&#xff09; 1. 校验相关 (1) 给当前表单绑上整个的数据对象&#xff1a;el-form > :model"ruleForm" 绑…
阅读更多...
云服务器是不是云盘？

云服务器是不是云盘？

​　　云服务器是不是云盘?云服务器和云盘是两个不同的概念&#xff0c;尽管它们都是云计算服务的一部分。云服务器是一种提供计算能力的服务&#xff0c;可以运行各种应用程序和服务&#xff0c;而云盘则是一种提供数据存储和共享服务的工具。 具体来说&#xff1a; 云服务器…
阅读更多...
【Qt】事件

【Qt】事件

目录 一、介绍 二、进入离开事件 三、鼠标事件 3.1 鼠标单击事件 3.2 鼠标释放事件 3.3 鼠标双击事件 3.4 鼠标移动事件 3.5 滚轮事件 四、按键事件 4.1 单个按键 4.2 组合按键 五、定时器 5.1 QTimerEvent类 5.2 QTimer类 5.3 获取系统日期及时间 六、窗口移…
阅读更多...
蓝桥杯刷题 前缀和与差分-[NewOJ P1819]推箱子（C++）

蓝桥杯刷题 前缀和与差分-[NewOJ P1819]推箱子（C++）

题目描述 在一个高度为H的箱子前方&#xff0c;有一个长和高为N的障碍物。 障碍物的每一列存在一个连续的缺口&#xff0c;第i列的缺口从第l各单位到第h个单位&#xff08;从底部由0开始数&#xff09;。 现在请你清理出一条高度为H的通道&#xff0c;使得箱子可以直接推出去。…
阅读更多...
深度学习理论基础（二）深度神经网络DNN

深度学习理论基础（二）深度神经网络DNN

目录 一、基础知识点Ⅰ 参数部分Ⅱ 模型部分 二、深度神经网络模型搭建1. 准备数据集2. 划分数据集3. 搭建模型4. 训练网络5. 测试网络6. 保存与导入模型 神经网络通过学习大量样本的输入与输出特征之间的关系&#xff0c;以拟合出输入与输出之间的方程&#xff0c;学习完成后&…
阅读更多...
每日一题（leetcode31）：下一个排列-思维

每日一题（leetcode31）：下一个排列-思维

思路&#xff1a;从后往前找到第一个nums[i-1]>nums[i] 然后从后往前(len-1 -->i(包含))找到第一个大于nums[i-1]的数&#xff0c;与nums[i-1]交换&#xff0c;然后对下标区间为[i,len-1]的元素进行排序。 class Solution { public:void nextPermutation(vector<in…
阅读更多...
[深度学习] 无人车环境准备

[深度学习] 无人车环境准备

1. 安装过程基本遵循以下步骤 电脑端环境配置 - OriginBot智能机器人开源套件 需要注意以下两点&#xff1a; 1> 由于深度学习需要的包和镜像体积都比较大&#xff0c;所以虚拟机硬盘大小建议120GB 2> 虚拟机的网络适配器应该设置为桥接模式&#xff0c;如果使用NAT模…
阅读更多...
vivado 使用网表插入调试探测流程

vivado 使用网表插入调试探测流程

使用网表插入调试探测流程 在 Vivado 工具中插入调试核的过程以分层方式来演示 &#xff0c; 以应对多样化的 Vivado 用户组的不同需求 &#xff1a; • 最高层是根据选定调试的一组信号线来自动创建并配置 Integrated Logic Analyzer (ILA) 核的简单向导。 • 下一层是“…
阅读更多...
File，IO流，递归详解

File，IO流，递归详解

File类 介绍 java.io.File类是Java语言提供了用来描述文件和目录(文件夹)的 构造 方法 注意&#xff1a; 构造方法中通常用的是第一个方法文件和目录可以通过File封装成对象File封装的对象仅仅是一个路径名&#xff0c;它是可以存在的&#xff0c;也可以不存在 绝对路径…
阅读更多...
【二分查找】Leetcode x 的平方根

【二分查找】Leetcode x 的平方根

题目解析 69. x 的平方根 这道题表面是没有顺序性&#xff0c;但是我们可以发现如果使用枚举策略&#xff0c;它是包含顺序性质的&#xff0c;因此我们将枚举算法改进成二分算法 算法讲解 我们让left指针指向1&#xff0c; right指针指向x 如果当前的mid计算出来的平方 &g…
阅读更多...
什么是商家转账到零钱

什么是商家转账到零钱

商家转账到零钱是什么&#xff1f; 通过商家转账到零钱这个功能&#xff0c;如果我们系统需要对用户支付费用&#xff0c;比如发放佣金、提成、退款之类的&#xff0c;可以直接转账到用户的微信零钱。 【商家转账到零钱】是【企业付款到零钱】的升级版&#xff0c;2022年5月1…
阅读更多...
怀俄明探空站数据解算PWV和Tm

怀俄明探空站数据解算PWV和Tm

1. Matlab 获取代码可关注公众号WZZHHH回复&#xff08;怀俄明探空站数据解算PWV和Tm&#xff09;&#xff0c;或者咸鱼关注&#xff1a;WZZHHH123 怀俄明探空站数据解算PWV和Tm&#xff1a; 有关 Matlab 获取代码可关注公众号WZZHHH回复&#xff08;怀俄明多线程下载&#…
阅读更多...
语音助手背后的魔法：一文揭秘NLP在智能助手中的应用

语音助手背后的魔法：一文揭秘NLP在智能助手中的应用

自然语言处理&#xff08;NLP&#xff09;正逐渐渗透到我们生活的每一个角落。在今天的大盘点中&#xff0c;我们将深入探索NLP在实际生活场景中的多样化应用&#xff0c;以及它在各个案例中所展现出的强大能力。 NLP技术如今已成为智能生活的关键驱动力&#xff0c;它让机器能…
阅读更多...
wordpress全站开发指南-面向开发者及深度用户（全中文实操）--php数组与基本循环

wordpress全站开发指南-面向开发者及深度用户（全中文实操）--php数组与基本循环

php数组与基本循环 <?php$myName"xixi";$namesarray(xixi1,xixi2,xixi3); ?> <p> Hi ,my name is <?php echo $myName; ?> </p> <p> Hi,my name is <?php echo $names[0] ?> </p> <p> Hi,my name is <?…
阅读更多...
Open CASCADE学习|放样建模

Open CASCADE学习|放样建模

在CAD软件中&#xff0c;Loft&#xff08;放样&#xff09;功能则是用于创建三维实体或曲面的重要工具。通过选取两个或多个横截面&#xff0c;并沿这些横截面进行放样&#xff0c;可以生成复杂的三维模型。在CAD放样功能的操作中&#xff0c;用户可以选择不同的选项来定制放样…
阅读更多...
创新数智化全场景福利解决方案，打造极致员工体验

创新数智化全场景福利解决方案，打造极致员工体验

众所周知&#xff0c;企业面临两个市场&#xff0c;一个是前端的产品&#xff08;服务&#xff09;市场&#xff0c;面对的是客户&#xff0c;另一个便是后端市场&#xff0c;即愈来愈烈的人才市场。在风云变幻、人潮涌动的知识经济时代&#xff0c;员工已成为企业未来的竞争关…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023