Java 多线程

最新推荐文章于 2023-05-17 10:58:57 发布

鱼尾巴选手

最新推荐文章于 2023-05-17 10:58:57 发布

阅读量200

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/weixin_62918925/article/details/126354623

版权

多线程

1. 线程介绍

1.1 进程

进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。
进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程。

1.2 线程

线程由进程创建的，是进程的一个实体；一个进程可以拥有多个线程。

单线程：同一个时刻，只允许执行一个线程。
多线程：同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口。
并发：同一个时刻，多个任务交替执行，造成一种”貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发。
并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行。

2. 线程使用

2.1 继承Thread类

Demo：

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

        Cat cat = new Cat();
        cat.start();    // 启动线程，最终会执行Cat的run方法

    }
}

// run 方法是 Thread 类实现了 Runnable 接口的 run 方法
class Cat extends Thread {
    int times = 0;

    @Override
    public void run() { // 重写 run 方法，写上自己的业务逻辑

        while (true) {
            // 该线程每隔1秒在控制台输出
            System.out.println("喵喵，我是猫猫" + (++times));
            // 让该线程休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times == 5) {
                break;
            }
        }

    }
}

**注意：**为什么cat调用的是start方法而不是直接调用run方法？因为如果直接调用run方法相当于主函数调用方法，后面还有代码的话不会执行，要等到run方法执行完毕才会执行，这样就不是多线程了。

2.2 实现Runnable接口

java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然不可能了。java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创
建线程。

Demo：

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

        Tiger tiger = new Tiger();
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.start();

    }
}

class Animal {
}

class Tiger extends Animal implements Runnable {

    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫..");
    }
}

// 线程代理类，模拟一个极简单的Thread类
class ThreadProxy implements Runnable {

    private Runnable target = null;

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start() {
        start0();
    }
    public void start0(){
        run();
    }
}

**说明：**实现Runnable接口不能直接调用start()方法，所以要使用静态代理的方法；来实现创建线程。

2.3 以上二者的区别

从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口。
实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable接口。

2.4 多个子线程案例

请编写一个程序，创建两个线程，一个线程每隔1秒出"hello,world" 输出10次，退出；一个线程每隔1秒输出"hi" ，输出 5次退出。

public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();    // 启动第一个线程
        thread2.start();    // 启动第二个线程
        System.out.println("main线程继续");

    }
}

class T1 implements Runnable {
    private int count = 0;

    @Override
    public void run() {
        // 每隔1秒输出hello world，输出10次
        while (true) {
            count++;
            System.out.println("hello world");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

class T2 implements Runnable {
    private int count = 0;

    @Override
    public void run() {
        // 每隔1秒输出hi，输出5次
        while (true) {
            count++;
            System.out.println("hi");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5) {
                break;
            }
        }
    }
}

2.5 线程终止

当线程完成任务后，会自动退出。
还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式。

Demo：

启动一个线程，要求在main线程中去停止线程t

public class ThreadExit {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();

        // 希望main线程去控制t1 线程的终止，必须可以修改loop，让t1退出run方法    -->通知方式
        System.out.println("main线程休眠10s...");
        Thread.sleep(10*1000);
        t1.setLoop(false);

    }
}

class T extends Thread{
    private int count=0;
    // 设置一个控制变量
    private boolean loop=true;

    @Override
    public void run() {
        while (loop){
            try {
                Thread.sleep(50);   //   让当前线程休眠50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中.."+(++count));
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

3. 线程方法

3.1 常用方法第一组（线程中断）

方法名	作用
setName	设置线程名称，使之与参数name相同
getName	返回该线程的名称
start	使该线程开始执行；Java虚拟机底层调用该线程的start0方法
run	调用线程对象run方法
setPriority	更改线程的优先级
getPriority	获取线程的优先级
sleep	在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
interrupt	中断线程

注意事项&细节：

start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程。
线程优先级的范围：常用的有三种MAX（10）、MIN（1）、NORM（5）。
interrupt，中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程。
sleep：线程的静态方法，使当前线程休眠。

Demo：

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        // 测试方法
        T t = new T();
        t.setName("Cat");
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();  // 启动子线程


        // 主线程打印5 hi，再中断 子线程的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi" + i);
        }

        t.interrupt();  // 当执行到该语句时，就中断 t 线程的休眠


    }
}

class T extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "  吃包子~~~~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + " 休眠中~~~");
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                // 当该线程执行到一个interrupt时，就会catch一个异常，可以加入  业务代码
                System.out.println(Thread.currentThread().getName() + "被 interrupt了");
            }
        }
    }
}

运行结果为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5fhTAS6Y-1660567797431)(https://raw.githubusercontent.com/CatFishn/blog_img/main/img/202208051630602.png)]

因为执行了interrupt方法，所以子线程还没有休眠20秒，便又重新开始执行了。

3.2 常用方法第二组（线程插队）

方法名	作用
yield	线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功。
join	线程的插队。插队的线程旦插队成功，则肯定先执行完插入的线程所有的任务。

Demo：

创建一个子线程，每隔1s输出hello，输出20次，主线程每隔1秒，输出hi，输出20次。要求：两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续。

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();

        for (int i = 0; i < 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程吃了" + i + "包子");
            if(i==5){
                System.out.println("主线程让 子线程 先吃");
                t2.join();
            }
        }

    }
}

class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(1000); // 休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程吃了" + i + "包子");
        }
    }
}

运行得到的一段结果为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xwFFhJ0F-1660567797433)(https://raw.githubusercontent.com/CatFishn/blog_img/main/img/202208052139923.png)]

3.3 练习

主线程每隔1s，输出hi，一共10次；当输出到hi5时，启动一个子线程（要求实现Runnable），每隔1s输出hello，等该线程输出10hello后，退出；主线程继续输出hi，直到主线程退出。

public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        T3 t3 = new T3();
        Thread thread = new Thread(t3);

        for (int i = 1; i <= 10; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
            if (i == 5) {   // 主线程输出了5次hi
                thread.start(); // 启动子线程，输出hello
                thread.join();  // 立即将子线程，插队，让其先执行
            }
            if (i == 10) {
                System.out.println("主线程结束...");
            }
        }
    }
}

class T3 implements Runnable {
    private int count = 0;

    @Override
    public void run() {
        while (true) {

            System.out.println("hello " + (++count));

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (count == 10) {
                System.out.println("子线程结束...");
                break;
            }
        }
    }

}

运行结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F2IH3UJj-1660567797433)(https://raw.githubusercontent.com/CatFishn/blog_img/main/img/202208052202842.png)]

3.4 守护线程

用户线程：也叫工作线程，当线程的任务执行完或通知方式结束。
守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束。
常见的守护线程：垃圾回收机制。

Demo：

public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        // 希望当main线程结束后，子线程自动结束
        // 将子线程设为守护线程
        myDaemonThread.setDaemon(true);	// 设置为守护线程
        myDaemonThread.start();

        for (int i = 0; i < 10; i++) {  // main线程
            System.out.println("AA辛苦工作...");
            Thread.sleep(1000);
        }

    }
}

class MyDaemonThread extends Thread{
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("BB和CC快乐聊天~~~");
        }
    }
}

4. 线程生命周期

线程的几种状态：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FPldlvFI-1660567797434)(https://raw.githubusercontent.com/CatFishn/blog_img/main/img/202208061458698.png)]

线程的状态转换图：

状态转换

5. Synchronized

线程同步机制：

在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。
也可以这里理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。

同步具体方法-synchronized：

同步代码块。

synchronized(/*对象*/){	// 得到对象的锁，才能操作同步代码
    // 需要同步的代码
}

synchronized还可以放在方法声明中，表示整个方法为同步方法。

public synchronized void m(String name){
    // 需要被同步的代码
}

6. 互斥锁

基本介绍：

Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。
同步的局限性：导致程序的执行效率要降低
同步方法（非静态的）的锁可以是this，也可以是其他对象(要求是同一个对象)。
同步方法（静态的）的锁为当前类本身。

注意事项和细节：

同步方法如果没有使用static修饰：默认锁对象为this
如果方法使用static修饰，默认锁对象：当前类.class
实现的落地步骤:
需要先分析上锁的代码；选择同步代码块或同步方法；要求多个线程的锁对象为同一个即可!

7. 死锁

含义：

多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程是一定要避免死锁的发生。

模拟线程死锁：

public class DeadLock {
    public static void main(String[] args) {
        DeadLockDemo a = new DeadLockDemo(true);
        DeadLockDemo b = new DeadLockDemo(false);
        a.setName("A线程");
        b.setName("B线程");
        a.start();
        b.start();

    }
}

class DeadLockDemo extends Thread {
    // 使用static，保证多线程共享一个对象
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if (flag) {
            synchronized (o1) {
                System.out.println(Thread.currentThread().getName() + "进入1");
                synchronized (o2) {
                    System.out.println(Thread.currentThread().getName() + "进入2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + "进入3");
                synchronized (o1) {
                    System.out.println(Thread.currentThread().getName() + "进入4");
                }
            }
        }
    }
}

执行上面代码，会一直卡住：

8. 释放锁

下面的操作会释放锁：

当前线程的同步方法、同步代码块执行结束；
当前线程在同步代码块、同步方法中遇到break、return；
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束；
当前线程在同步代码块、同步方法中执行了线程对象的wait(方法，当前线程暂停，并释放锁；

下面的操作不会释放锁：

线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁;
线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。**提示：**应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用！

9. Homework

第一题：（1）在main方法中启动两个线程；（2）第1个线程循环随机打印100以内的整数；（3）直到第2个线程从键盘读取了"Q"命令。

import java.util.Scanner;

public class Homework01 {
    public static void main(String[] args) {
        A a = new A();
        B b = new B(a); // 注意：将a传给B
        a.start();
        b.start();

    }
}

// 创建A线程类
class A extends Thread {
    private boolean loop = true;

    @Override
    public void run() {
        while (loop) {
            // 随机输出1-100数字
            System.out.println((int) (Math.random() * 100 + 1));
            // 休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        System.out.println("A线程退出...");

    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

// 直到第2个线程从键盘读取了“Q”命令
class B extends Thread {
    private A a;
    private Scanner scanner = new Scanner(System.in);

    public B(A a) { // 构造器中传入A类对象
        this.a = a;
    }

    @Override
    public void run() {
        while (true) {
            // 接受用户输入
            System.out.println("请输入你的指令(Q)退出");
            char key = scanner.next().charAt(0);
            if (key == 'Q') {
                // 以通知方式结束A线程
                a.setLoop(false);
                System.out.println("B线程退出...");
                break;
            }
        }
    }
}

运行结果：

第二题：（1）有2个用户分别从同一个卡上取钱（总额: 10000）；（2）每次都取1000,当余额不足时，就不能取款了；（3）不能出现超取现象 => 线程同步问题。

public class Homework02 {
    public static void main(String[] args) {
        T t = new T();
        Thread thread1 = new Thread(t);
        Thread thread2 = new Thread(t);
        thread1.start();
        thread2.start();
    }
}

// 涉及到多个线程共享资源，所以使用实现Runnable方式
class T implements Runnable {
    private int money = 10000;

    @Override
    public void run() {
        while (true) {
            // 多个线程执行到这里时，争夺this对象锁
            synchronized (this) {
                // 判断余额是否足够取出
                if (money < 1000) {
                    System.out.println("余额不足");
                    break;
                }

                money -= 1000;
                System.out.println(Thread.currentThread().getName() + "取出1000 当前余额为：" + money);
            }
            // 休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}