线程基础

1、线程介绍

1.1、线程相关概念

程序（program）：是完成特定任务，用某种语言编写的一组的集合（例如：java代码就是一个程序）
进程：是指运行中的程序（比如：我现在使用的Typora）
- 进程是程序的一次执行过程
- 是动态的过程：由他自身的产生、存在和消亡的过程
什么是线程？
- 线程是由进程创建的，是进程的一个实体
- 一个进程可以拥有多个线程
其他概念
- 单线程：同一时刻，只允许执行一个线程
- 多线程：同一时刻，可以执行多个线程
- 并发：同一时刻，多个任务交替执行（单CPU实现多任务就是并发）
- 并行：同一时刻，多个任务同时执行（多核CPU可以实现并行）

2、线程基本使用

创建线程的两种方式：

2.1、继承Thread 类，重写run方法

线程应用案例1——继承Thread类：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 实体类
 * <p>
 *    1.当一个类继承 Thread类， 该类就可以当做线程使用
 *    2.我们会重写run方法，写上自己的业务代码
 *    3.run Thread 类实现了 Runnable 接口的run方法
 *     public void run() {
 *         if (target != null) {
 *             target.run();
 *         }
 *     }
 * </p>
 */
public class Cat extends Thread{
    int times = 0;
    @Override
    public void run() {
        while(true) {
            // 每隔1秒，在控制台输出“喵喵,我是小猫咪"
            System.out.println("喵喵，我是小喵咪" + (++times) + "线程名=" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 当times输出8次是我们就退出线程
            if (times == 80) {
                break;
            }
        }
    }
}

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 线程的基本使用
 */
public class Thread01{
    public static void main(String[] args) throws InterruptedException {
        // 创建一个Cat对象,当线程使用
        Cat cat = new Cat();
        // 启动线程
        cat.start();
        // 当main线程启动一个子线程 Thread-0，主线程不会阻塞，会继续执行
        // 主线程和子线程是交替执行的
        System.out.println("主线程继续执行" + Thread.currentThread().getName());
        for (int i = 0; i < 60; i++) {
            System.out.println("主线程 i = " + i);
            // 让主线成休眠
            Thread.sleep(1000);
        }
    }
}

启动线程为什么是start：

启动线程最终会执行cat的run方法，而cat.run()方法就是一个普通的方法，并没有真正的启动多线程，run执行完毕后才会向下执行

我们可以追踪下源码进行分析

2.2、实现Runnable接口，重写run方法

线程应用案例2——实现Runnable接口：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 通过实现Runnable接口， 开发线程类
 */
public class Dog implements Runnable{

    int count = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("Hello World!" + (++count) + Thread.currentThread().getName());

            // 休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        // 这里不能调用start dog.start();
        Thread thread = new Thread(dog);
        thread.start();
    }
}

在Thread thread = new Thread(dog);中使用到了一种设计模式：静态代理模式

在Thread类里面有个私有属性：==private Runnable target;==当我们实现Runnable接口的run方法时会调用如下的方法，

当我们==Thread thread = new Thread(dog)==;时，因为Dog实现了Runnable接口，所以这里的==dog==就相当于时==target==

个人理解：如有不对的地方请批评指正

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

2.3、多线程的简单演示：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 在main线程启动两个子线程
 */
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();
    }
}

class T1 implements Runnable{
    int count = 0;
    @Override
    public void run() {
        while (true){
            // 给隔1秒输出”hello world!" 输出10次
            System.out.println("Hello World!" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

class T2 implements Runnable {
    int count = 0;
    @Override
    public void run() {
        while (true){
            // 给隔1秒输出”hello world!" 输出10次
            System.out.println("Hello" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5) {
                break;
            }
        }
    }
}

子线程的理解：

2.4、继承Thread 和实现Runnable 的区别

从java设计角度看，通过继承Thread和实现Runnable接口来创建线程本质上没有区别
实现Runnable接口方式更加适合多个线程共享一个资源的情况，避免了单继承的限制
建议使用Runnable接口的方式开启线程。

2.5、线程终止

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

线程终止演示：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 线程的退出
 */
public class ThreadEit_ {
    public static void main(String[] args) throws InterruptedException {
        Th th = new Th();
        th.start();

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

class Th extends Thread{
    int count = 0;
    private boolean loop = true;
    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Th 运行中...." + (++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是一个简单方法调用，不会启动新线程
- 线程优先级的范围
- interrupt，中断线程，单并没有真正的结束线程，一般用于中断正在休眠线程
- sleep：线程的静态方法，使当前线程休眠

演示：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 线程方法的使用
 */
public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        // 测试方法
        Th th = new Th();
        th.setName("小豪");
        th.setPriority(Thread.MIN_PRIORITY);
        // 启动子线程
        th.start();

        // 主线程打印5 hi，然后进行中断，子线程休眠
        for (int i = 0; i <= 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }
        System.out.println(th.getName() + " 线程优先级 = " + th.getPriority());

        // 当执行到这里时，就会中断 th线程的休眠
        th.interrupt();

    }
}

class Th extends Thread {

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

3.2、线程的常用方法二：

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

线程join说明：

示例演示：

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

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 线程方法的使用
 */
public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {

        T2 t2 = new T2();
        t2.start();

        for (int i = 1; i<= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程吃了" + i + " 包子");
            if (i == 5) {
                System.out.println("主线程让子线程先吃");
                // join，线程插队
                // t2.join(); 这里是让t2线程执行完毕

                Thread.yield();
                System.out.println("子线程吃完主线程接着吃");
            }
        }
    }
}

class T2 extends Thread {

    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程吃了" + i + "包子");
        }
    }
}

3.3、用户线程和守护线程

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

演示示例：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 守护线程演示
 */
public class ThreadMethod0 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        myDaemonThread.start();
        // 当主线程结束后，子线程自动结束，只需将子线程设置为守护线程即可
        myDaemonThread.setDaemon(true);
        for (int i = 1; i <= 10; i++) {
            System.out.println("小豪再敲代码");
            Thread.sleep(10000);
        }
    }
}

class MyDaemonThread extends Thread {
    @Override
    public void run() {
        for (; ;) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("小豪在和女友聊天......");
        }
    }
}

4、线程生命周期

线程状态。线程可以处于以下状态之一：

NEW : 尚未启动的线程处于此状态。
RUNNABLE 在Java虚拟机中执行的线程处于此状态。
BLOCKED 被阻塞等待监视器锁定的线程处于此状态。
WAITING 正在等待另一个线程执行特定动作的线程处于此状态。
TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
TERMINATED 已退出的线程处于此状态。

实例演示：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 线程的状态
 */
public class Threadstate_ {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + "状态 " + t.getState());
        t.start();

        while (Thread.State.TERMINATED != t.getState()) {
            System.out.println(t.getName() + "状态 " + t.getState());
            Thread.sleep(500);
        }
        System.out.println(t.getName() + "状态 " + t.getState());
    }
}

class T extends Thread {

    @Override
    public void run() {
        while (true){
            for (int i = 0; i < 10; i++) {
                System.out.println("hi " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

运行结果：

5、Synchronized

线程同步机制：在多线程编程，一些敏感数据不允许被多线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。

同步具体方法—Synchronized

同步代码块

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

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

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

使用synchronized解决火车票超卖问题

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 模拟售票
 */
public class SellTicket {
    public static void main(String[] args) {
        // 解决火车票超卖问题
        SellTicket03  sellTicket03 = new SellTicket03();
        Thread thread1 = new Thread(sellTicket03);
        Thread thread2 = new Thread(sellTicket03);
        Thread thread3 = new Thread(sellTicket03);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

/** 实现接口方式, 使用synchronized实现线程同步**/
class SellTicket03 implements Runnable{
    private  int ticketNum = 100;
    private boolean loop = true;
    public synchronized void m() { // 同步方法，在同一时刻，只能有一个线程来执行run方法
        if (ticketNum <= 0) {
            System.out.println("售票结束...");
            loop = false;
            return;
        }

        // 休眠50秒
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票"
                + " 剩余票数 = " + (--ticketNum));
    }
    @Override
    public void run() {
        while (loop) {
            // m方法是一个同步方法
            m();
        }
    }
}

6、互斥锁

基本介绍：

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

同步方法（静态的）的锁为当前类本身

注意事项和细节：

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

7、死锁

基本介绍：

多个线程都占用了对方的锁资源，始终不肯释放，就导致了死锁

案例演示：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/4
 * @description 死锁模拟
 */
public class DeadLock_ {
    public static void main(String[] args) {
        // 模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B线程");
        A.start();
        B.start();
    }
}

class DeadLockDemo extends Thread {
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;

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

    @Override
    public void run() {
        // 1.如果flag为 T，线程A 就会先得到 o1对象锁， 然后尝试去获取 o2 对象锁
        // 2.如果线程A 得不到 o2 对象锁，就会Blocked
        // 3.如果flag为 F, 线程B 就会先得到 o2对象锁，然后尝试去获取 o1 对象锁
        // 4.如果线程B 得不到 o1 对象锁， 就会Blocked
        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");
                }
            }
        }
    }
}

释放锁

下面操作会释放锁
- 当前线程的同步方法、同步代码块执行结束
- 当前线程在同步代码块、同步方法中遇到break、return
- 当前线程在同步代码块、同步方法中出现了未处理的Error或者Exception，导致异常结束
- 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁
下面操作不会释放锁
- 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
- 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁应避免suspend()和resume()方法来控制线程

Java进阶——多线程基础

线程基础

1、线程介绍

1.1、线程相关概念

2、线程基本使用

创建线程的两种方式：

2.1、继承Thread 类，重写run方法

2.2、实现Runnable接口，重写run方法

2.3、多线程的简单演示：

2.4、继承Thread 和实现Runnable 的区别

2.5、线程终止

3、线程方法

3.1、线程常用的方法一：

3.2、线程的常用方法二：

3.3、用户线程和守护线程

4、线程生命周期

5、Synchronized

6、互斥锁

7、死锁

释放锁

热门文章

最新文章

相关课程

相关电子书

相关实验场景

Java进阶——多线程基础

线程基础

1、线程介绍

1.1、线程相关概念

2、线程基本使用

创建线程的两种方式：

2.1、 继承Thread 类，重写run方法

2.2、实现Runnable接口，重写run方法

2.3、多线程的简单演示：

2.4、继承Thread 和实现Runnable 的区别

2.5、线程终止

3、线程方法

3.1、线程常用的方法一：

3.2、线程的常用方法二：

3.3、用户线程和守护线程

4、线程生命周期

5、Synchronized

6、互斥锁

7、死锁

释放锁

热门文章

最新文章

相关课程

相关电子书

相关实验场景

2.1、继承Thread 类，重写run方法