JUC - 线程基础

已于 2022-09-21 20:20:09 修改
阅读量105 收藏
点赞数
分类专栏： JUC 文章标签： java
于 2022-09-21 10:39:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/futurn_hero/article/details/126966834
版权

JUC - 线程基础

线程有哪几种状态? 分别说明从一种状态到另一种状态转变有哪些方式?

在这里插入图片描述
线程创建 start方法开启后，可以通过 synchronized关键字/Lock锁将其阻塞 (等待获取一个排它锁，如果其线程释放了锁就会结束此状态)，或者通过sleep将其沉睡*(等待其它线程显式地唤醒，否则不会被分配 CPU 时间片)*，但是依旧持有锁/如果是wait就释放锁，进入等待, 最终结束，线程死亡（可以是线程结束任务之后自己结束，或者产生了异常而结束）。

try {
    Thread.sleep(3000L);
} catch (InterruptedException e) {
    e.printStackTrace();
}
使用 sleep 方法可以让让当前线程休眠，时间一到当前线程继续往下执行，在任何地方都能使用，但需要捕获 InterruptedException 异常。

synchronized (lock){
    try {
        lock.wait();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
而使用 wait 方法则必须放在 synchronized 块里面，同样需要捕获 InterruptedException 异常，并且需要获取对象的锁。
synchronized (lock) {
    // 随机唤醒
    lock.notify();

    // 唤醒全部
    lock.notifyAll();
}
还需要额外的方法 notify/ notifyAll 进行唤醒，它们同样需要放在 synchronized 块里面，且获取对象的锁。
当然也可以使用带时间的 wait(long millis) 方法，时间一到，无需其他线程唤醒，也会重新竞争获取对象的锁继续执行。


因为 sleep 是让当前线程休眠，不涉及到对象类，也不需要获得对象的锁，所以是线程类的方法。wait 是让获得对象锁的线程实现等待，前提是要楚获得对象的锁，所以是类的方法。

如下代码所示，wait 可以释放当前线程对 lock 对象锁的持有，而 sleep 则不会。
Object lock = new Object();
synchronized (lock) {
    try {
        lock.wait(3000L);
        Thread.sleep(2000L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

通常线程有哪几种使用方式?

  • 实现 Runnable 接口；
  • 实现 Callable 接口；
  • 继承 Thread 类。
实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。 

实现 Runnable 接口
public class MyRunnable implements Runnable {
    public void run() {
        // ...
    }
}
public static void main(String[] args) {
    MyRunnable instance = new MyRunnable();
    Thread thread = new Thread(instance);
    thread.start();
}


实现 Callable 接口
与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。
著作权归https://pdai.tech所有。
链接：https://pdai.tech/md/java/thread/java-thread-x-thread-basic.html

public class MyCallable implements Callable<Integer> {
    public Integer call() {
        return 123;
    }
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
    MyCallable mc = new MyCallable();
    FutureTask<Integer> ft = new FutureTask<>(mc);
    Thread thread = new Thread(ft);
    thread.start();
    System.out.println(ft.get());
}

继承 Thread 类
同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runable 接口。 当调用 start() 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 run() 方法。
public class MyThread extends Thread {
    public void run() {
        // ...
    }
}

public static void main(String[] args) {
    MyThread mt = new MyThread();
    mt.start();
}

实现接口 VS 继承 Thread
实现接口会更好一些，因为:

  • Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
  • 类可能只要求可执行就行，继承整个 Thread 类开销过大。

基础线程机制有哪些?

Executor
Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。
主要有三种 Executor:

  • CachedThreadPool: 一个任务创建一个线程；
  • FixedThreadPool: 所有任务只能使用固定大小的线程；
  • SingleThreadExecutor: 相当于大小为 1 的 FixedThreadPool。
public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    for (int i = 0; i < 5; i++) {
        executorService.execute(new MyRunnable());
    }
    executorService.shutdown();
}

线程的中断方式有哪些？

一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。
通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。

对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。

public class InterruptExample {

    private static class MyThread1 extends Thread {
        @Override
        public void run() {
            try {
                Thread.sleep(2000);
                System.out.println("Thread run");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

	public static void main(String[] args) throws InterruptedException {
	    Thread thread1 = new MyThread1();
	    thread1.start();
	    thread1.interrupt();
	    System.out.println("Main run");
	}
}

在这里插入图片描述

interrupted()
如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。

但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。

public class InterruptExample {

    private static class MyThread2 extends Thread {
        @Override
        public void run() {
            while (!interrupted()) {
                // ..
            }
            System.out.println("Thread end");
        }
    }

	public static void main(String[] args) throws InterruptedException {
	    Thread thread2 = new MyThread2();
	    thread2.start();
	    thread2.interrupt();
	}
}

在这里插入图片描述
Executor 的中断操作
调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 shutdownNow() 方法，则相当于调用每个线程的 interrupt() 方法。

class InterruptExample1 {


    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> {
            try {
                Thread.sleep(2000);
                System.out.println("Thread run");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executorService.shutdownNow();
        System.out.println("Main run");
    }
}

在这里插入图片描述

线程的互斥同步方式有哪些? 如何比较和选择?

Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。

synchronized

  • 同步一个代码块
public void func() {
//这里的this就是对象锁，只有加到static对象或者方法上，才是类锁，锁住一整个类
    synchronized (this) {
        // ...
    }
}

它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。

对于以下代码，使用 ExecutorService 执行了两个线程，由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。

class SynchronizedExample {

    public static void main(String[] args) {
        SynchronizedExample e1 = new SynchronizedExample();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> e1.func1());
        executorService.execute(() -> e1.func1());
    }

    public void func1() {
//        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + ": " +  i + " ");
            }
        }
//    }
}

在这里插入图片描述

class SynchronizedExample {

	public static void main(String[] args) {
	    SynchronizedExample e1 = new SynchronizedExample();
	    ExecutorService executorService = Executors.newCachedThreadPool();
	    executorService.execute(() -> e1.func1());
	    executorService.execute(() -> e1.func1());
        executorService.shutdown();
	}
  
    public void func1() {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        }
    }
//同步一个普通方法，它和同步代码块一样，作用于同一个对象。
    public synchronized void func2() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + ": " +  i + " ");
            }
    }
}

在这里插入图片描述
对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不需要同步。从输出结果可以看出，两个线程交叉执行。
其实就是没有锁

class SynchronizedExample {


    public static void main(String[] args) {
        SynchronizedExample e1 = new SynchronizedExample();
        SynchronizedExample e2 = new SynchronizedExample();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> e1.func1());
        executorService.execute(() -> e2.func1());
        executorService.shutdown();
    }

    public void func1() {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + ": " +  i + " ");
            }
        }
    }
}

在这里插入图片描述

可以通过锁静态对象或者锁本类来管理
作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。

class SynchronizedExample {
    static Object object = new Object();

    public static void main(String[] args) {
        SynchronizedExample e1 = new SynchronizedExample();
        SynchronizedExample e2 = new SynchronizedExample();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> e1.func1());
        executorService.execute(() -> e2.func1());
        executorService.shutdown();
    }

    public void func1() {
		//synchronized (SynchronizedExample.class) {
        synchronized (object) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + ": " +  i + " ");
            }
        }
    }
}

在这里插入图片描述

ReentrantLock
ReentrantLock 是 java.util.concurrent(J.U.C)包中的锁。

class LockExample {

    private Lock lock = new ReentrantLock();


	public static void main(String[] args) {
	    LockExample lockExample = new LockExample();
	    ExecutorService executorService = Executors.newCachedThreadPool();
	    executorService.execute(() -> lockExample.func());
	    executorService.execute(() -> lockExample.func());
	}

    public void func() {
        lock.lock();
        try {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        } finally {
            lock.unlock(); // 确保释放锁，从而避免发生死锁。
        }
    }
}

在这里插入图片描述

  1. 锁的实现 synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
  2. 性能 新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
  3. 等待可中断 当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。 ReentrantLock 可中断，而 synchronized 不行。
  4. 公平锁 公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。 synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
  5. 锁绑定多个条件 一个 ReentrantLock 可以同时绑定多个 Condition 对象。
    其实锁中也有wait和notify，

在这里插入图片描述

线程之间有哪些协作方式?

当多个线程可以一起工作去解决某个问题时，如果某些部分必须在其它部分之前完成，那么就需要对线程进行协调。

join()
在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。
对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。


class JoinExample {


	public static void main(String[] args) {
	    JoinExample example = new JoinExample();
	    example.test();
	}

    private class A extends Thread {
        @Override
        public void run() {
            System.out.println("A");
        }
    }

    private class B extends Thread {

        private A a;

        B(A a) {
            this.a = a;
        }

        @Override
        public void run() {
            try {
                a.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("B");
        }
    }

    public void test() {
        A a = new A();
        B b = new B(a);
        b.start();
        a.start();
    }
    
}

在这里插入图片描述

wait() notify() notifyAll()

调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。

它们都属于 Object 的一部分，而不属于 Thread。 只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 IllegalMonitorStateExeception。

使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。

class WaitNotifyExample {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        WaitNotifyExample example = new WaitNotifyExample();
        executorService.execute(()->example.after());
        executorService.execute(()->example.before());
                executorService.shutdown();
    }
    public synchronized void before() {
        this.notifyAll();
        System.out.println("before!");
    }

    public synchronized void after() {
        try {
            this.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("after!");

    }
}

在这里插入图片描述

wait() 和 sleep() 的区别

  • wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
  • wait() 会释放锁，sleep() 不会。

await() signal() signalAll()

java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。

使用 Lock 来获取一个 Condition 对象。

class AwaitSignalExample {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        AwaitSignalExample example = new AwaitSignalExample();
        executorService.execute(() -> example.after());
        executorService.execute(() -> example.before());
    }

    public void before() {
        lock.lock();
        try {
            System.out.println("before");
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void after() {
        lock.lock();
        try {
            condition.await();
            System.out.println("after");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
是一个Bug
关注
专栏目录
JUC 全家桶系列，一键三连就完事了
扛麻袋的少年的博客
12-07 1483
JUC、AQS、CAS、Lock、ReentrantLock、Atomic、Future、Executors、JUC工具类、JUC集合类、Fork-Join框架
JUC-并发面试题
最新发布
HBryce24的博客
02-06 1091
并发面试题
多线程中Thread中wait(),sleep(),join()方法
zucc_shen的博客
07-11 911
join() 这里join用法，在A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行。如果写入参数，就是等待几毫秒。参数是0的话就是一直等待，知道唤醒，等价于没有参数。 join的原理，看源码 public final synchronized void join(long millis) throws InterruptedException { long base = System.currentTimeMillis(); l
java排他_Java排他锁实现的代码详解
weixin_30263409的博客
02-18 623
这篇文章主要介绍了Java编程实现排他锁的相关内容，叙述了实现此代码锁所需要的功能，以及作者的解决方案，然后向大家分享了设计源码，需要的朋友可以参考下。一 .前言某年某月某天，同事说需要一个文件排他锁功能，需求如下：(1)写操作是排他属性(2)适用于同一进程的多线程／也适用于多进程的排他操作(3)容错性：获得锁的进程若Crash，不影响到后续进程的正常获取锁二 .解决方案1. 最初的构想在Java...
java thread wait参数_Java 并发：线程基础
weixin_36054458的博客
02-16 338
死亡(Terminated)可以是线程结束任务之后自己结束，或者产生了异常而结束。线程使用方式有三种使用线程的方法:实现 Runnable 接口；实现 Callable 接口；继承 Thread 类。实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。实现 Ru...
Java多线程学习之wait、notify/notifyAll 详解
weixin_30827565的博客
10-06 604
1、wait()、notify/notifyAll() 方法是Object的本地final方法，无法被重写。 2、wait()使当前线程阻塞，前提是 必须先获得锁，一般配合synchronized 关键字使用，即，一般在synchronized 同步代码块里使用 wait()、notify/notifyAll() 方法。 3、 由于 wait()、notify/notifyAll() 在syn...
Thread-Wait
qq_34412668的博客
12-22 354
实例 package com.example.demo.thread; public class WaitTest { public static Object lock = new Object(); public static void main(String[] args) throws InterruptedException { WaitThread1 waitThread1 = new WaitThread1(); WaitThread2 wa
Java 多线程与并发(7-26)-JUC - 类汇总和学习指南.pdf
07-22
在学习 JUC 框架之前，建议先学习 Java 并发编程的基础知识，例如 synchronized、volatile、final 等关键字的使用。 学习 JUC 框架的步骤： 1. 先了解 JUC 框架的整体结构和分类 2. 了解每个部分的详细内容 3. ...
个人学习-JUC-笔记
02-25
Java并发编程是Java开发中的重要领域，而JUC（Java Util Concurrency）是Java平台提供的一套高级并发工具包，它极大地简化了多线程和并发控制的复杂性。本笔记主要围绕尚硅谷周阳老师的JUC课程展开，旨在帮助个人...
A-JUC-JVM-Java并发知识..pdf
06-05
#### JUC多线程及高并发 Java并发编程包（java.util.concurrent，简称JUC）封装了大量用于高并发编程的工具类和接口，其中涉及了线程池、阻塞队列、同步器、原子操作类等。在并发环境下，可以有效降低线程创建和管理...
Java线程中wait,await,sleep,yield,join用法总结.pdf
06-28
Java线程中wait、await、sleep、yield、join用法汇总，文章里面总结了这些关键字的用法，并且里面带有源码帮助分析用法，此一文就可以理解这些关键字用法，推荐拥有
生产者和消费者的例子
mxdxm8899的专栏
07-04 174
/////// ProducerConsumer.java//// @author 叶雨//// 这是个很重要的Thread例子。需要注意的是：// wait() 必须在synchronized 函数或者代码块里面// wait()会让已经获得synchronized 函数或者代码块控制权的Thread暂时休息，并且丧失控制权// 这个时候，由于该线程丧失控制权并且进入等待，其他线程就能取得控...
java一个方法排他调用_并发艺术--java并发编程基础
weixin_42105816的博客
02-28 149
前言java语言内置对多线程的支持。那为什么使用多线程的？首先线程是操作系统最小的调度单元，多核心，多个线程可以同时执行，能够提升程序性能。但过多的线程也会导致问题(效率下降，死锁)。一、线程简介1.1 什么是线程进程：现代操作系统运行一个程序时，会为其创建一个进程。(进程可认为是运行的程序，活的程序)。线程：现代操作系统的最新调度单位就是线程，线程也称为轻量级进程(Light Weight Pr...
java threads wait_java多线程七(Thread wait的用法)
weixin_42443797的博客
02-13 999
Thread类中把线程从running状态转化为非runnable状态有一个方法就是wait方法。wait方法是线程的等待状态。我们来看看wait方法简单运用下面是一个wait方法的代码packageThreadTest;/*** thread wait方法详解*@authorlingfengz**/public classWaitTest {public static voidmain(Stri...
Java Thread.wait()
热门推荐
asing1elife's blog
09-30 1万+
wait() 和 notify() 必须在 synchronized 语句块中使用 wait() 是强迫一个线程等待 notify() 是通知一个线程继续运行 更多精彩 更多技术博客，请移步 asing1elife’s blog 功能 wait() 是针对已经获取对象锁的线程进行操作 当线程获取对象锁后，调用 wait() 主动释放对象锁，同时该线程休眠 直到其他线程调用 notify(...
java thread.await_Java Thread.sleep/Thread.join/Thread.yield/Object.wait/Condition.await 详解
weixin_30592681的博客
03-07 622
前言线程并发系列文章：前面几篇文章深入分析了Thread、synchronized、AQS等相关知识，基础打好了，接下来就来分析常见的几个方法的应用、原理及其容易混淆的地方。通过本篇文章，你将了解到：1、Thread.sleep 应用及原理2、Thread.yield 应用及原理3、Thread.join 应用及原理4、Object.wait 应用及原理5、Condition.await 应用及原...
java thread.await_使用Thread.Sleep进行等待的替代方法
weixin_35045973的博客
02-17 1223
在代码分析运行期间，我看到了一个令人惊讶的违规行为：Thread.Sleep()的使用是有缺陷设计的标志 .这种违规导致Peter Richie's article为什么这究竟构成了糟糕的设计 .我们都知道线程创建很昂贵，线程中的阻塞意味着池上的争用 . 我们也知道每个线程将分配一个兆内存，因此它应该有一个短的寿命，在UI上阻塞是邪恶的，使用睡眠时间是不可靠的等等 . 这导致我的观点，如果你真的需...
java线程中的await()和signal()
hell_world!
07-17 4544
今天有需求接触一下多线程。
Thread wait notify用法
天下无双
03-14 965
if (jobThread == null) { jobThread = new Thread(new OrderJobRunnable()); jobThread.start(); } else { synchronized (jobThread) { jobThread.notify(); } } private class OrderJob
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值