Java 多线程

沃兹基硕德1006

已于 2023-08-08 13:49:39 修改

阅读量31

点赞数

分类专栏： Java 文章标签： java jvm 开发语言

于 2023-08-08 13:46:26 首次发布

本文链接：https://blog.csdn.net/f5976823000/article/details/132164458

版权

Java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一、概念

多线程：同时让程序做多件事情，提高效率。

如果想让多个事情同时运行，就需要用到多线程，如软件中的耗时操作、所有的聊天软件、所有的服务器等。

并发：同一时刻，多个指令在单个CPU上交替执行。

并行：同一时刻，多个指令在多个CPU上同时执行。

二、多线程的实现方式

1、继承Thread类

自己定义一个类继承Thread
重写里面的run方法
创建子类对象，启动多线程

自己定义的类：

package demo01;

// 自己写一个类，继承Thread
public class MyThread extends Thread{
    // 重写run方法
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"：hello");
        }
    }
}

测试类中：

package demo01;

public class test {
    public static void main(String[] args) {

        // 创建子类对象，启动线程（注意是用start()方法，这个才是开启线程），我们会看到线程1和线程2交替执行的效果
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();

        mt1.setName("线程1");
        mt2.setName("线程2");
        
        mt1.start();
        mt2.start();
    }

}

2、Runnable接口

自己定义一个类实现Runnable接口
重写里面的run方法
创建自己的类对象，创建Thread类对象，开启线程

自己写的类：

package demo01;

// 自己定义一个类实现Runnable接口
public class MyRun implements Runnable{

    // 重写里面的run方法
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            // 先获取当前线程的对象，哪条线程执行了，就返回哪条线程
            Thread t = Thread.currentThread();
            
            // 不能直接调用getName()方法，这是定义在Thread类中的
            System.out.println(t.getName()+"：hello");
        }
    }
}

测试类中：

package demo01;

public class test {
    public static void main(String[] args) {
        // 创建自己的类对象，表示多线程要执行的任务
        MyRun mr = new MyRun();

        // 创建线程对象
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        t1.setName("线程1");
        t2.setName("线程2");

        // 开启线程
        t1.start();
        t2.start();
    }
}

3、Callable接口

第三种方式可以获取多线程运行的结果。

自己写一个类，实现Callable接口
重写里面的call（有返回值的，返回多线程运行的结果）
创建自己写的类的对象（表示多线程要执行的任务）
创建Future实现类FutureTask的对象（管理多线程运行的结果）
创建Thread类的对象，并启动线程

自己写的类中：

package demo01;

import java.util.concurrent.Callable;

// 自己写一个类，实现Callable接口，这里的泛型，表示线程结果的类型
public class MyCallable implements Callable<Integer> {
    // 重写里面的call方法
    @Override
    public Integer call() throws Exception{
        // 求1-100之前的和
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}

测试类中：

package demo01;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        // 创建自己写的类的对象，表示多线程要执行的任务
        MyCallable mc = new MyCallable();

        // 创建Future实现类FutureTask的对象，管理多线程运行的结果
        FutureTask<Integer> ft= new FutureTask<>(mc);

        // 创建Thread类的对象，并启动线程
        Thread t = new Thread(ft);
        t.start();

        // 获取多线程运行的结果
        Integer res = ft.get();
        System.out.println(res);
    }

}

小结：

三、多线程的常见成员方法

1、4个基本方法

使用继承Thread类方式：

package demo01;

public class MyThread extends Thread{

    // 继承父类Thread的设置线程名字的构造方法
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run(){

        for (int i = 0; i < 100; i++) {
            // 让线程休眠，哪条线程执行到这个方法，哪条线程就会在这里停留设置的时间，方法的参数就是设置的时间，单位是毫秒，当时间到了之后，线程会自动执行下面的其它代码。
            // 注意这里只能用try...catch包裹，因为父类run()方法里没有抛出异常
            // 使用线程休眠，让程序每隔一秒，打印输出一次
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(getName()+"："+i);
        }
    }
}

测试类中：

package demo01;

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

        // 创建线程对象，设置线程名字：setName()、构造方法（这个需要再自己写的那个类里面继承一下构造方法）
        MyThread t1 = new MyThread("线程1");
        MyThread t2 = new MyThread("线程2");

        // 开启线程，如果没有设置线程的名字，则默认格式是：Thread-数字，从0开始
        t1.start();
        t2.start();

        // 获取当前线程的对象，这里写在main方法中，获取的是main线程的对象，即主线程。JVM虚拟机启动后，会自动启动都跳线程，其中一条线程就是main线程，作用就是调用main方法，并执行里面的代码。
        Thread t = Thread.currentThread();
        System.out.println(t.getName());
    }
}

2、线程优先级

使用Runable接口：

package demo01;

public class MyRunable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread());
        }
    }
}

测试类：

package demo01;


public class test {
    public static void main(String[] args) {
        MyRunable mr = new MyRunable();

        Thread t1 = new Thread(mr,"线程1");
        Thread t2 = new Thread(mr,"线程2");

        // 查看默认优先级
        System.out.println(t1.getPriority());
        System.out.println(t2.getPriority());

        // 设置优先级
        t1.setPriority(1);
        t2.setPriority(10);
        t1.start();
        t2.start();
    }

}

3、守护、出让、插入线程

守护线程：

package demo01;

public class test {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();

        t1.setName("线程1");
        t2.setName("线程2");

        // 把线程2设置为守护线程，当其他的非守护线程执行完后，守护线程会陆续结束，即当线程1执行完后，线程2也没有存在的必要了，也就是这里的线程2是没办法打印到100的
        t2.setDaemon(true);

        t1.start();
        t2.start();
    }

}

// 线程1
class MyThread1 extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"："+i);
        }
    }
}

// 线程2
class MyThread2 extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"："+i);
        }
    }
}

出让线程：

package demo01;

public class test {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();
    }
}

class MyThread extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"："+i);
            // 出让当前CPU的执行权，让结果尽可能均匀一点
            Thread.yield();
        }
    }
}

插入线程：

package demo01;

public class test {
    public static void main(String[] args) throws InterruptedException {
        MyThread t = new MyThread();
        t.setName("线程1");
        t.start();

        // 把线程1插入到main线程之前
        t.join();
        
        // 执行在main线程中的：
        // 默认这个会优先于线程1执行
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程："+i);
        }
    }
}


class MyThread extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"："+i);

        }
    }
}

四、多线程的其他问题

1、线程的生命周期

sleep方法会让线程睡眠，睡眠时间到了后，也不会立马执行下面的代码，它会变成就绪状态，等抢到了CPU，才会执行下面的代码。

2、线程的安全问题

卖电影票：100张票，3个窗口卖票，设计一个程序模拟卖票过程。

package demo01;

public class test {
    public static void main(String[] args)  {

        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

class MyThread extends Thread{
    // static表示这个变量由所有线程共享
    static int ticket = 0;
    @Override
    public void run() {
        while (true){
            if(ticket<100){
                // 给线程加一个卖一张票停一会的方法
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                ticket++;
                System.out.println(getName()+"正在卖第"+ticket+"张票");
            }else {
                break;
            }
        }
    }
}

结果运行却是：

不仅有重复的，还有越界的现象。

这是因为：线程在执行时，具有随机性，CPU的执行权随时可能被其他线程抢走。可能上一秒线程1ticket++，还没来得及打印，下一秒线程2也ticket++了，最后线程3++，打印的是加了三次之后的数据。

3、同步代码块

这就需要同步代码块：把操作共享数据的代码锁起来。

锁是默认打开的，有一个线程进去，则锁自动关闭，直到里面的代码全部执行完毕，线程出来，锁自动打开。

因此，上面的代码可以这么修改：

class MyThread extends Thread{
    static int ticket = 0;

    // 锁对象：一定要是唯一的（在前面加static关键字）
    static Object obj = new Object();
    
    @Override
    public void run() {
        while (true){
            // 同步代码块：括号内是锁对象，可以是任意的一个对象。
            synchronized (obj){
                if(ticket<100){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket++;
                    System.out.println(getName()+"正在卖第"+ticket+"张票");
                }else {
                    break;
                }
            }
        }
    }
}

注意别把锁写在循环外面，不然一个线程进去了得等循环结束才能出来，票都卖光了。

锁对象一定要唯一，不然对于每个线程来说都是全新的锁对象，那就达不到效果，一般会写当前类的字节码文件对象，上面的可以写：MyThread.class

4、同步方法

如果想把方法里面的代码全部锁起来，可以把synchronized关键字加到方法上：

锁对象是Java规定好的：

如果当前方法是非静态的，锁对象就是this。

如果是静态的，那就是当前类的字节码文件对象。

如果不知道哪些需要写成同步方法，可以先写同步代码块，再把同步代码块里面的抽取成同步方法。

package demo01;

public class test {
    public static void main(String[] args)  {
        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        Thread t3 = new Thread(mr);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();

    }
}

class MyRunnable implements Runnable{
    // 由于用的第二种方式，这里不需要加static，因为第二种实现时只需要创建一次MyRunnable的对象，它是作为一个参数传递给线程执行的，只会创建一次对象，就不需要加了。
    int ticket = 0;

    @Override
    public void run() {
        while (true) {
            // 同步方法：ctrl+alt+m，同步代码块抽取
            if (method()) break;
        }

    }

    // 非静态，锁对象是this
    private synchronized boolean method() {
        if(ticket==100) {
            return true;
        } else {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            ticket++;
            System.out.println(Thread.currentThread().getName()+"在卖第"+ticket+"张票");
        }
        return false;
    }
}

注：StringBuilder的实例用于多个线程是不安全的，如果需要则建议使用StringBuffer

5、锁和死锁

在使用同步代码块和同步方法时，我们并不能手动操控锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象：Lock

Lock中提供了获得锁和释放锁的方法：

void lock()：获得锁、void unlock()：释放锁

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化：

Lock lock = new ReentrantLock();

package demo01;

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

public class test {
    public static void main(String[] args)  {

        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}


class MyThread extends Thread{
    static int ticket = 0;

    // 创建锁对象：必须是唯一的（加static）
    static Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            // 同步代码块，手动上锁
            lock.lock();
            try {
                if(ticket==100){
                    break;
                } else {
                    Thread.sleep(100);
                    ticket++;
                    System.out.println(getName()+"在卖第"+ticket+"张票");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 改进后，解锁写在finally中，无论如何这个代码都会执行，避免了按部就班将解锁写在最后，但是循环在上面先break了，锁还没解，一直执行的问题
                lock.unlock();
            }

        }
    }

}

死锁：锁的嵌套，避免犯这个错误。

6、等待唤醒机制（生产者和消费者）

经典多线程协作模式。

默认两条线程的执行是随机的，而等待唤醒机制则可以让它们轮流交替执行。

两条线程中，一条线程是生产者（生产数据），另一条是消费者（消费数据）。

过程：

常用方法：

方式一：

package demo01;


public class test {
    public static void main(String[] args)  {

        // 创建线程对象
        Cook c = new Cook();
        Foodie f = new Foodie();
        c.setName("厨师");
        f.setName("吃货");

        // 开启线程
        c.start();
        f.start();

    }
}


// 厨师（生产者）
class Cook extends Thread{

    @Override
    public void run() {
        // 四步走：1、写个循环。2、同步代码块。3、判断共享数据是否到了末尾，分支写。4、没有到末尾，执行核心逻辑
        while (true) {
            synchronized (Desk.obj) {
                // 如果吃货已经吃不下了，就停止
                if(Desk.count==0) {
                    break;

                } else {
                    // 如果没有吃完面条：判断桌子上有没有面条——有：等。没有：制作食物，修改桌子上的食物状态，唤醒吃货。
                    if(Desk.foodFlag==1){
                        try {
                            Desk.obj.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    } else {
                        System.out.println("厨师做了一碗面");
                        Desk.foodFlag = 1;
                        Desk.obj.notifyAll();
                    }

                }

            }
        }
    }
}


// 吃货（消费者）
class Foodie extends Thread{

    @Override
    public void run() {
        // 四步走：1、写个循环。2、同步代码块。3、判断共享数据是否到了末尾，分支写。4、没有到末尾，执行核心逻辑
        while (true){
            synchronized (Desk.obj){
                // 如果吃货吃完面条，就停下
                if(Desk.count==0){
                    break;
                } else {
                    // 如果没有吃完面条：判断桌子上有没有面条——有：吃，唤醒厨师，吃的碗数-1，桌子上的食物状态修改。没有：等。
                    if(Desk.foodFlag==0){
                        // 要用锁对象去调用，这句话是让当前线程跟锁进行绑定，因为在唤醒的时候不能唤醒所有的线程，为了方便，就用锁绑定它们，这样可以一致。
                        try {
                            Desk.obj.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    } else {
                        Desk.count--;
                        System.out.println("吃货正在吃面条，还能再吃"+Desk.count+"碗");
                        Desk.foodFlag = 0;
                        Desk.obj.notifyAll();
                    }

                }
            }

        }
    }
}


// 桌子：控制生产者和消费者的执行
class Desk extends Thread{

    // 变量：桌子上的食物状态，为了方便外界调用，直接静态
    // 0：没有食物，1：有食物
    public static  int foodFlag = 0;

    // 吃货最多能吃十碗
    public static int count = 10;

    // 锁对象
    public static Object obj = new Object();

}

方式二：利用阻塞队列实现

借助如上“管道”实现，put数据时，如果管道满了，厨师只能等待，这叫阻塞，take数据时，管道里没有了，取不出来了，吃货只能等着，这也叫阻塞。

阻塞队列四个接口：Iterable、Collection、Queue、BlockingQueue

需要创建实现类的对象：

ArrayBlockingQueue：底层是数组，有界（创建时必须执行队列长度）

LinkedBlockingQueue：底层是链表，无界，但也有最大值，是int的最大值。

package demo01;

import java.util.concurrent.ArrayBlockingQueue;

public class test {
    public static void main(String[] args)  {

        // 注意，生产者和消费者必须使用同一个队列
        // 阻塞队列，参数是阻塞队列中最多能放几碗面
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);

        // 创建线程对象，并把阻塞队列传递过去
        Cook c = new Cook(queue);
        Foodie f = new Foodie(queue);

        // 开启线程
        c.start();
        f.start();

    }
}

// 生产者
class Cook extends Thread{
    // 成员变量
    ArrayBlockingQueue<String> queue;

    // 给成员变量赋值为阻塞队列，主要是为了让Cook和Foodie中的阻塞队列是同一个
    public Cook(ArrayBlockingQueue<String> q){
        this.queue = q;
    }

    @Override
    public void run() {
        // 这里不需要写锁，put源码中有
        while (true){
            // 不断把面放入阻塞队列
            try {
                queue.put("面");
                // 输出语句，定义在锁的外面，打印的时候就会跟我们想的不一样，但是这个不会对数据造成什么影响。
                System.out.println("厨师放了一碗面");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

// 消费者
class Foodie extends Thread{
    // 成员变量
    ArrayBlockingQueue<String> queue;

    // 给成员变量赋值为阻塞队列
    public Foodie(ArrayBlockingQueue<String> q){
        this.queue = q;
    }

    @Override
    public void run() {
        // 这里也不用写锁
        while (true){
            // 不断从阻塞队列中获取面
            try {
                String food = queue.take();
                System.out.println(food);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

7、线程的状态

Java虚拟机没有定义运行状态。

当线程抢夺到CPU后，虚拟机就会把线程交给操作系统去管理，因此不再定义运行状态。

8、线程池

“碗柜”比喻。

原理：

创建池子，池子中是空的
提交任务时，池子会创建新的线程对象，任务执行完毕，线程归还给池子。下回再次提交任务时，不需要创建新的线程，直接复用已有的线程即可
但是如果提交任务时，池子中没有空闲线程，也无法创建新的线程，任务就会排队等待。

代码实现：

创建线程池
提交任务（此时线程池底层会自动创建线程，直到达到规定上限）
所有任务执行完毕，关闭线程池（实际开发中一般不关）

工具类创建线程池：

第一个方法不是没有上限，上限是int最大值。

package demo01;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class test {
    public static void main(String[] args)  {
        // 获取线程池对象
        ExecutorService pool1 = Executors.newCachedThreadPool();
        // ExecutorService pool1 = Executors.newFixedThreadPool(3); 表示最多只能有3个线程

        // 提交任务
        pool1.submit(new MyRunnable());
        pool1.submit(new MyRunnable());
        pool1.submit(new MyRunnable());
        pool1.submit(new MyRunnable());

        // 销毁线程（一般不会销毁）
        // pool1.shutdown();

    }
}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"："+i);
        }
    }
}

自定义线程池：

当核心线程都在忙，队列中已经排满，才会去创建临时线程。

任务也不是按照提交顺序执行的。

不断的提交任务，会有以下三个临界点：

①当核心线程满时，再提交任务就会排队

②当核心线程满，队伍满时，会创建临时线程

③当核心线程满，队伍满，临时线程满时，会触发任务拒绝策略

任务拒绝策略：

package demo01;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class test {
    public static void main(String[] args)  {
        /* 7个参数：
           参数1：核心线程数量，不能小于0
           参数2：最大线程数量，不能小于0，>=核心线程数量
           参数3：空闲线程最大存活时间，不能小于0
           参数4：空闲线程最大存活时间的单位，用TimeUnit指定
           参数5：任务队列，不能为null
           参数6：创建线程工厂，不能为null
           参数7：任务拒绝策略，不能为null */
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                3,
                6,
                60, 
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3), 
                Executors.defaultThreadFactory(),
                // 任务拒绝策略，是一个线程池的匿名内部类
                new ThreadPoolExecutor.AbortPolicy()  
        );

    }
}

线程池多大合适？

4核8线程：CPU有4个大脑同时并行去做4件事，超线程技术可以把原本的4个大脑虚拟成8个，同时去做8件事，对于4核8线程的CPU而言，最大并行数为8。

项目分两种：

CPU密集型：计算较多，读取文件和数据库的操作较少。

则线程池最大为：最大并行数+1

如4核8线程，应设计线程池最大为9，+1是因为，如果前面的线程出问题了，这个可以候补顶上。

I/O密集型：读取文件较多。

则线程池最大为：最大并行数 * 期望CPU利用率 * [(CPU计算时间+等待时间) / CPU计算时间]

这里CPU计算时间和等待时间可以使用工具thread dump获取。