多线程学习笔记

最新推荐文章于 2024-05-29 11:04:29 发布
最新推荐文章于 2024-05-29 11:04:29 发布
阅读量180 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengguofeng0328/article/details/113561304
版权

廖神学习地址

一、多线程基础

1、进程

在计算机中，我们把一个任务称为一个进程，浏览器就是一个进程，视频播放器是另一个进程，类似的，音乐播放器和Word都是进程。

某些进程内部还需要同时执行多个子任务。例如，我们在使用Word时，Word可以让我们一边打字，一边进行拼写检查，同时还可以在后台进行打印，我们把子任务称为线程。

进程和线程的关系就是：一个进程可以包含一个或多个线程，但至少会有一个线程。

某些进程内部还需要同时执行多个子任务。例如，我们在使用Word时，Word可以让我们一边打字，一边进行拼写检查，同时还可以在后台进行打印，我们把子任务称为线程。

进程和线程的关系就是：一个进程可以包含一个或多个线程，但至少会有一个线程。

2、进程 vs 线程

进程和线程是包含关系，但是多任务既可以由多进程实现，也可以由单进程内的多线程实现，还可以混合多进程＋多线程。
具体采用哪种方式，要考虑到进程和线程的特点。
和多线程相比，多进程的缺点在于：
创建进程比创建线程开销大，尤其是在Windows系统上；
进程间通信比线程间通信要慢，因为线程间通信就是读写同一个变量，速度很快。
而多进程的优点在于：
多进程稳定性比多线程高，因为在多进程的情况下，一个进程崩溃不会影响其他进程，而在多线程的情况下，任何一个线程崩溃会直接导致整个进程崩溃。

3、多线程

Java语言内置了多线程支持：一个Java程序实际上是一个JVM进程，JVM进程用一个主线程来执行main()方法，在main()方法内部，我们又可以启动多个线程。此外，JVM还有负责垃圾回收的其他工作线程等。

因此，对于大多数Java程序来说，我们说多任务，实际上是说如何使用多线程实现多任务。

和单线程相比，多线程编程的特点在于：多线程经常需要读写共享数据，并且需要同步。例如，播放电影时，就必须由一个线程播放视频，另一个线程播放音频，两个线程需要协调运行，否则画面和声音就不同步。因此，多线程编程的复杂度高，调试更困难。

Java多线程编程的特点又在于：

多线程模型是Java程序最基本的并发模型；
后续读写网络、数据库、Web开发等都依赖Java多线程模型。

二、创建新线程

方法一：从Thread派生一个自定义类，然后覆写run()方法：

public class Main {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start(); // 启动新线程
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("start new thread!");
    }
}

方法二：创建Thread实例时，传入一个Runnable实例

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start(); // 启动新线程
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("start new thread!");
    }
}

当然也可以使用lambda表达式这里就不做演示。
注意：
1、sleep()传入的参数是毫秒。调整暂停时间的大小，我们可以看到main线程和t线程执行的先后顺序。
2、直接调用run方法是无效的，和普通的调用没什么区别，只有调用start方法才会创建线程。
3、线程的优先级：

Thread.setPriority(int n) // 1~10, 默认值5

三、线程的状态

New：新创建的线程，尚未执行；（新建）
Runnable：运行中的线程，正在执行run()方法的Java代码；（就绪）
Blocked：运行中的线程，因为某些操作被阻塞而挂起；（阻塞）
Waiting：运行中的线程，因为某些操作在等待中；（等待）
Timed Waiting：运行中的线程，因为执行sleep()方法正在计时等待；（计时等待）
Terminated：线程已终止，因为run()方法执行完毕。（终止）

线程种植的原因：

  1. 线程正常终止：run()方法执行到return语句返回；
  2. 线程意外终止：run()方法因为未捕获的异常导致线程终止；
  3. 对某个线程的Thread实例调用stop()方法强制终止（强烈不推荐使用）。

一个线程还可以等待另一个线程直到其运行结束。例如，main线程在启动t线程后，可以通过**t.join()**等待t线程结束后再继续运行。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            System.out.println("hello");
        });
        System.out.println("start");
        t.start();
        t.join();
        System.out.println("end");
    }
}

四、中断线程

1、interrupt()方法

对目标线程调用interrupt()方法可以请求中断一个线程，目标线程通过检测isInterrupted()标志获取自身是否已中断。
如果目标线程处于等待状态，该线程会捕获到InterruptedException；
目标线程检测到isInterrupted()为true或者捕获了InterruptedException都应该立刻结束自身线程；

2、volatile关键字

在Java虚拟机中，变量的值保存在主内存中，但是，当线程访问变量时，它会先获取一个副本，并保存在自己的工作内存中。如果线程修改了变量的值，虚拟机会在某个时刻把修改后的值回写到主内存，但是，这个时间是不确定的！
就会导致，a线程改变了变量，只是把这个变量写到副本中，这样b线程读取的话读取不是最新的，这样多线程变量不一致出现错误。

因此，volatile关键字的目的是告诉虚拟机：
每次访问变量时，总是获取主内存的最新值；
每次修改变量后，立刻回写到主内存。
volatile关键字解决的是可见性问题：当一个线程修改了某个共享变量的值，其他线程能够立刻看到修改后的值。

五、守护线程

在一般情况下，线程执行完毕之后jvm虚拟机也会退出，进程结束。但是会有一些线程是无限循环的，无法结束，所以jvm也不会退出，造成资源一直浪费。这时就需要守护线程了。
守护线程：
守护线程是指为其他线程服务的线程。在JVM中，所有非守护线程都执行完毕后，无论有没有守护线程，虚拟机都会自动退出。
如何创建守护线程呢？方法和普通线程一样，只是在调用start()方法前，调用setDaemon(true)把该线程标记为守护线程：

六、线程同步

1、synchronized关键字

先看一个例字

public class Main {
    public static void main(String[] args) throws Exception {
        var add = new AddThread();
        var dec = new DecThread();
        add.start();
        dec.start();
        add.join();
        dec.join();
        System.out.println(Counter.count);
    }
}

class Counter {
    public static int count = 0;
}

class AddThread extends Thread {
    public void run() {
        for (int i=0; i<10000; i++) { Counter.count += 1; }
    }
}

class DecThread extends Thread {
    public void run() {
        for (int i=0; i<10000; i++) { Counter.count -= 1; }
    }
}

代码很简单，两个线程执行 1w次加减操作，最后结果应该等于0.
但是执行发现每次结果都不一样。
这时我们需要加锁操作：

public class Main {
    public static void main(String[] args) throws Exception {
        var add = new AddThread();
        var dec = new DecThread();
        add.start();
        dec.start();
        add.join();
        dec.join();
        System.out.println(Counter.count);
    }
}

class Counter {
    public static final Object lock = new Object();
    public static int count = 0;
}

class AddThread extends Thread {
    public void run() {
        for (int i=0; i<10000; i++) {
            synchronized(Counter.lock) {
                Counter.count += 1;
            }
        }
    }
}

class DecThread extends Thread {
    public void run() {
        for (int i=0; i<10000; i++) {
            synchronized(Counter.lock) {
                Counter.count -= 1;
            }
        }
    }
}

这样最终结果就会为 0
把Counter.lock示意为一个锁，当A线程执行完之后会释放锁，在A线程未执行完时候，B线程获取不到这个锁也就不会执行，等待A释放锁之后B自己获得锁开始执行该线程。
概括一下：

  1. 找出修改共享变量的线程代码块；
  2. 选择一个共享实例作为锁；
  3. 使用synchronized(lockObject) { … }。
  4. 用synchronized修饰方法可以把整个方法变为同步代码块，synchronized方法加锁对象是this；

当然synchronized也可以修饰方法：

public void add(int n) {
    synchronized(this) { // 锁住this
        count += n;
    } // 解锁
}

上述代码等价于

public synchronized void add(int n) {
        count += n;
}

当修饰静态变量的时候，静态变量是针对于类的，所以修饰静态变量等价于修饰该类。

public synchronized static void test(int n) {
    ...
}
//这两个是等价的
public class Counter {
    public static void test(int n) {
        synchronized(Counter.class) {
            ...
        }
    }
}

synchronized关键字加锁机制，会降低执行效率，应该选择使用。

不需要synchronized的操作，JVM规范定义了几种原子操作：

  1. 基本类型（long和double除外）赋值，例如：int n = m；
  2. 引用类型赋值，例如：List list = anotherList。
  3. 当一个方法有两个复制语句的话则需要同步
//这时是不安全的 需要同步操作
public void setTest(int a,int b){
	this.bud=a;
	this.aud=b;
}

long和double是64位数据，JVM没有明确规定64位赋值操作是不是一个原子操作，不过在x64平台的JVM是把long和double的赋值作为原子操作实现的。

七、死锁

先看一段代码

public void add(int m) {
    synchronized(lockA) { // 获得lockA的锁
        this.value += m;
        synchronized(lockB) { // 获得lockB的锁
            this.another += m;
        } // 释放lockB的锁
    } // 释放lockA的锁
}

public void dec(int m) {
    synchronized(lockB) { // 获得lockB的锁
        this.another -= m;
        synchronized(lockA) { // 获得lockA的锁
            this.value -= m;
        } // 释放lockA的锁
    } // 释放lockB的锁
}

如果有两个线程A、B分别调用add方法和dec方法，
A线程首先获得lockA锁，B线程获得LockB锁，接着A线程想要去获得lockB锁就需要等待B线程释放，而B线程需要获得lockA锁，需要等待A线程释放，所以会无限循环下去，这就是死锁。
那应该正确的获取呢：
线程获取锁的顺序要一致。即严格按照先获取lockA，再获取lockB的顺序，改写dec()

public void dec(int m) {
    synchronized(lockA) { // 获得lockA的锁
        this.value -= m;
        synchronized(lockB) { // 获得lockB的锁
            this.another -= m;
        } // 释放lockB的锁
    } // 释放lockA的锁
}

八、wait和notifyAll和notify

先看一个例子

class TaskQueue {
    Queue<String> queue = new LinkedList<>();

    public synchronized void addTask(String s) {
        this.queue.add(s);
    }

    public synchronized String getTask() {
        while (queue.isEmpty()) {
        }
        return queue.remove();
    }
}

乍一看代码好像没什么问题，当有A B两个线程去调用addTask和getTask方法时，当B线程调用时，会一直处于循环中不会释放锁，所以A线程永远不会去执行。
我们想要的效果是：

  1. A线程可以往里添加。
  2. B线程可以清除。
    所以我们应该这样做，当队列为空时让其处于等待状态，等A线程添加进去之后唤醒B然后去清除。
    代码稍作修改：
class TaskQueue {
    Queue<String> queue = new LinkedList<>();

    public synchronized void addTask(String s) {
        this.queue.add(s);
        this.notify();
    }

    public synchronized String getTask() {
        while (queue.isEmpty()) {
        this.wait();
        }
        return queue.remove();
    }
}

总结：

  1. wait和notify用于多线程协调运行：
  2. 在synchronized内部可以调用wait()使线程进入等待状态；
  3. 必须在已获得的锁对象上调用wait()方法；
  4. 在synchronized内部可以调用notify()或notifyAll()唤醒其他等待线程；
  5. 必须在已获得的锁对象上调用notify()或notifyAll()方法；
  6. 已唤醒的线程还需要重新获得锁后才能继续执行。

九、ReentrantLock

public class Counter {
    private final Lock lock = new ReentrantLock();
    private int count;

    public void add(int n) {
        lock.lock();
        try {
            count += n;
        } finally {
            lock.unlock();
        }
    }
}

因为synchronized是Java语言层面提供的语法，所以我们不需要考虑异常，而ReentrantLock是Java代码实现的锁，我们就必须先获取锁，然后在finally中正确释放锁。

顾名思义，ReentrantLock是可重入锁，它和synchronized一样，一个线程可以多次获取同一个锁。

和synchronized不同的是，ReentrantLock可以尝试获取锁：

if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        ...
    } finally {
        lock.unlock();
    }
}

上述代码在尝试获取锁的时候，最多等待1秒。如果1秒后仍未获取到锁，tryLock()返回false，程序就可以做一些额外处理，而不是无限等待下去。

所以，使用ReentrantLock比直接使用synchronized更安全，线程在tryLock()失败的时候不会导致死锁。

十、Condition

class TaskQueue {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private Queue<String> queue = new LinkedList<>();

    public void addTask(String s) {
        lock.lock();
        try {
            queue.add(s);
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public String getTask() {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                condition.await();
            }
            return queue.remove();
        } finally {
            lock.unlock();
        }
    }
}

我们需要 lock调用newCondition实例一个Condition对象。
Condition提供的**await()、signal()、signalAll()原理和synchronized锁对象的wait()、notify()、notifyAll()**是一致的，并且其行为也是一样的：

  1. await()会释放当前锁，进入等待状态；
  2. signal()会唤醒某个等待线程；
  3. signalAll()会唤醒所有等待线程；
  4. 唤醒线程从await()返回后需要重新获得锁。
    此外。condition还可以尝试等待时间，如果超过等待时间没有被唤醒，则自动唤醒。
if (condition.await(1, TimeUnit.SECOND)) {
    // 被其他线程唤醒
} else {
    // 指定时间内没有被其他线程唤醒
}

十一、ReentrantLock

public class Counter {
    private final Lock lock = new ReentrantLock();
    private int[] counts = new int[10];

    public void inc(int index) {
        lock.lock();
        try {
            counts[index] += 1;
        } finally {
            lock.unlock();
        }
    }

    public int[] get() {
        lock.lock();
        try {
            return Arrays.copyOf(counts, counts.length);
        } finally {
            lock.unlock();
        }
    }
}

当线程调用inc()方法的时候，应该设置锁，但是当我们读取的时候调用get（）方法的时候是可以不需要锁的。那我们应该怎么满足这个要求呢。
ReadWriteLock可以解决该问题。

  • 只允许一个线程写入（其他线程既不能写入也不能读取）；
  • 没有写入时，多个线程允许同时读（提高性能）。
public class Counter {
    private final ReadWriteLock rwlock = new ReentrantReadWriteLock();
    private final Lock rlock = rwlock.readLock();
    private final Lock wlock = rwlock.writeLock();
    private int[] counts = new int[10];

    public void inc(int index) {
        wlock.lock(); // 加写锁
        try {
            counts[index] += 1;
        } finally {
            wlock.unlock(); // 释放写锁
        }
    }

    public int[] get() {
        rlock.lock(); // 加读锁
        try {
            return Arrays.copyOf(counts, counts.length);
        } finally {
            rlock.unlock(); // 释放读锁
        }
    }
}
炸了毛的猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程学习笔记05线程协作
asdfghjkl_zth的博客
02-01 2572
文章目录多线程学习笔记05线程协作线程通信解决方式1管程法解决方式2信号灯法 多线程学习笔记05线程协作 线程通信 应用场景：生产者和消费者问题 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费； 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止； 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。 我们来分析一下： 首先，这是一个线程同步问题，生产者和消费者共享同一个资
多任务的概念
yuxeaotao的博客
07-12 927
多任务的概念什么叫“多任务”呢？简单地说，就是操作系统可以同时运行多个任务。打个比方，你一边在用浏览器上网，一边在听MP3，一边在用Word赶作业，这就是多任务，至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行着，只是桌面上没有显示而已。 现在，多核CPU已经非常普及了，但是，即使过去的单核CPU，也可以执行多任务。由于CPU执行代码都是顺序执行的，那么，单核CPU是怎么执行多任务的呢...
java如何写线程外部类_廖雪峰Java读书笔记（六）--多线程（或称并发）
weixin_30647853的博客
02-23 205
1. 多线程基础首先要明白一些概念：进程：把一个任务称为一个进程，浏览器就是一个进程，视频播放器是另一个进程，类似的，音乐播放器和Word都是进程。线程：某些进程内部还需要同时执行多个子任务。例如，我们在使用Word时，Word可以让我们一边打字，一边进行拼写检查，同时还可以在后台进行打印，我们把子任务称为线程。注：操作系统调度的最小单位是线程。进程和线程的关系就是：一个进程可以包含一个或多个线程...
C#多线程学习笔记
wangyunman的博客
08-23 755
C#多线程 1、多线程使用一般方法 Thread t = new Thread(new ThreadStart(Method)); Method为无参函数，若要传递参数，可以将Method的参数设置为object类型。 2、多线程处理List 最近碰到了多线程处理List的问题，开始的想法是开启5个线程，每个线程轮流获取List中的字符串，但是处理完一个字符串就有一个问题，线程无法重用，线程重用可...
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3258
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
多线程基础学习笔记
旋风小陀螺
03-12 1475
多线程基础学习笔记
Java多线程学习笔记
Mike_ToUp
06-15 686
进程和线程的概念 进程：程序（任务）的执行过程。持有资源（共享内存，共享文件）和线程 线程：系统中最小的执行单元。同一进程中有多个线程。 线程共享进程的资源。 线程的交互：互斥/同步Java语言对线程的支持示意图： Thread常用方法：线程的创建：Thread（String name） / Thread（Runnable target）线程的方法： 启动线程：void start（） 线程休眠
java多线程学习笔记
weach的博客
12-19 611
java多线程
C++多线程学习笔记（一）
m0_63932570的博客
05-04 2094
今天是五月三号，五一放假五天，博主也就给自己放了三天假，去游山玩水，吃美食。今天是第四天了，也该慢慢找回学习的状态啦。所以今天博主也是改变自己最近懒惰的状态，来开始自己学习多线程的基础知识。多线程这部分内容对于java，c++爱好者应该不陌生，经常听到或看到的吧。建议在学完c++基础语言知识后的同学们，还是值得学一下这部分内容的（其实也不算很多内容）。下面我们正式开始来看看吧 1.理解多线程。 多线程并发指的是在同一个进程中执行多个线程。C++11提供了语言层面上的多线程，包含在头文件<threa
JAVA 多线程学习笔记
03-27
这篇学习笔记将深入探讨Java多线程的核心概念、实现方式以及相关工具的使用。 一、多线程基础 1. 线程与进程：在操作系统中，进程是资源分配的基本单位，而线程是程序执行的基本单位。每个进程至少有一个主线程，...
多线程学习笔记.docx
06-16
在多线程编程中，进程和线程是两个核心概念。进程是操作系统资源分配的基本单位，每个独立执行的程序都对应一个进程。而线程则是程序执行的最小单元，是进程内部的一条执行路径。多线程是指在一个应用程序中存在多个...
多线程 学习笔记.md
05-04
多线程 学习笔记.md
JUC之八：FutureTask源码解析 JDK8
zhengguofeng0328的博客
03-11 2833
文章目录前言1、FutureTask结构1.1、继承结构1.2、构造方法1.3、状态1.4、消费者链表1.5、成员属性2、实现Runnable接口的run方法3、Future接口方法（get等）3.1、get方法3.2、cancel、isCancelled4、总结 前言 我们知道线程Runnable接口是无法获取线程执行的返回值的，需要用另一个接口Callable接口是可以获取线程返回值的。 区别： Runnable接口没有返回值，Callable接口有返回值。又因为是返回值是泛型，所以任何类型的返回
JUC之十一：CompletableFuture用法详解
zhengguofeng0328的博客
07-10 1349
前面介绍了FutureTask，获取异步执行结果通过get的形式，而且会阻塞主线程，随着开发的越来越越复杂已经无法满足真正开发场景，我们试想一个例子：我们再炒菜的时候，先洗菜，切菜，炒菜，盛菜，然后吃。。。。。。如果还用原来的future来操作的话，需要每一个步骤get出前一个线程的结果之后才能继续执行，导致主线程阻塞，无法去干别的事情，如蒸米饭等，为了解决这一问题提出了的异步编程方式。
JAVA系列：NIO
最新发布
zhengguofeng0328的博客
05-29 1134
先来看一下NIO的工作流程图：缓冲区的作用就是作为运输数据的载体，在通道中进行运输，是在内存中进行的，本质其实就是数组。JAVA NIO包内声明了常见的几种数据类型的实现。 2.2、基本使用 编写一个输出方法： 使用完整示例 上面代码的输出顺序以及解释：初始化数据并插入 方法进行初始化buffer数组大小。初始值与相等，随着插入数据后移。flip操作 转换为读取模式，重置为，为0。 方法比较的是是否小于，表示是否读取结束。随着方法读取，后移，直到与相等，读取完毕。rewind操作 重现读取，把
JAVA系列：IO流
zhengguofeng0328的博客
05-10 854
1、字节流是原生的操作，字符流是处理之后的操作。和Reader的子类。和Writer的子类。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值