wen 编程最新 2024-01-31

多线程相关

1. 进程与线程

进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建、运行到消亡的过程。

线程是比进程更小的执行单位，一个进程在其执行的过程中可以产生多个线程。线程共享进程的堆和方法区的资源，同时线程还有私有的程序计数器、虚拟机栈和本地方法栈资源。

2. 并行与并发

并行：单位时间内，多个任务同时执行。

并发：同一时间段，多个任务都在执行（单位时间内不一定同时执行）。

3. 线程的生命周期（状态）

状态名称	说明
NEW	初始状态，线程被构建
RUNNABLE	运行状态，包括运行中和就绪两种状态
BLOCKED	阻塞状态，表示线程阻塞于锁
WAITING	等待状态，表示线程进入等待状态，如果其他线程不通知则不会唤醒
TIMED_WAITING	超时等待状态，经过指定等待时间后会自动唤醒
TERMINATED	终止状态，表示线程已经执行完毕

4. 线程的创建方式

4.1 继承Thread类

通过继承Thread类并重写run() 方法可以创建线程，调用start()方法来启动线程。

public class ThreadDemo01 {
    public static void main(String[] args) {
        MyThread01 t = new MyThread01();
        t.start(); // 线程名称：Thread-0
    }
}

/**
 * 继承Thread类
 */
class MyThread01 extends Thread {
    @Override
    public void run() {
        System.out.println("线程名称：" + Thread.currentThread().getName());
    }
}

由于Java中类的单继承特性，当一个类继承Thread类后就不能继承其它的类了。

4.2 实现Runnable接口

通过实现Runnable接口并重写run() 方法可以创建一个线程，同时可以继承其它的类。

public class ThreadDemo02 {
    public static void main(String[] args) {
        new Thread(new MyThread02()).start(); // 线程名称：Thread-0
    }
}

/**
 * 实现Runnable接口
 */
class MyThread02 extends Object implements Runnable {
    @Override
    public void run() {
        System.out.println("线程名称：" + Thread.currentThread().getName());
    }
}

采用这种方式创建线程时可以利用JDK1.8的新特性lambda表达式，无需实现Runnable接口的实现类，简化代码。

public class ThreadDemo02 {
    public static void main(String[] args) {
        new Thread(() -> System.out.println(Thread.currentThread().getName())).start();
    }
}

4.3 实现Callable接口

有返回值的任务必须实现Callable接口并重新call() 方法，返回值封装在future中，通过get()方法获取返回的Object，再结合线程池接口ExecutorService实现有返回值得线程运行。

import java.util.concurrent.*;

public class ThreadDemo03 {
    public static void main(String[] args) {
        // 创建单个线程的线程池
        ExecutorService es = Executors.newSingleThreadExecutor();
        // 提交任务到线程池并获取执行结果
        Future<Integer> future = es.submit(new MyThread03());
        // 关闭线程池
        es.shutdown();
        try {
            if (future.get() != null) {
                System.out.println("Callable子线程计算结果：" + future.get());
            } else {
                System.out.println("Callable子线程未获取到结果");
            }
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 实现Callable接口
 */
class MyThread03 implements Callable<Integer> {
    private int sum;
    @Override
    public Integer call() throws Exception {
        System.out.println("Callable子线程开始计算...");
        Thread.sleep(1000);
        for (int i = 0; i < 10; i++) {
            sum += i;
        }
        System.out.println("Callable子线程计算结束...");
        return sum;
    }
}

运行结果：

5. 线程终止的方式

正常运行结束：程序运行结束，线程自动结束；

使用退出标志退出线程：设置一个boolean类型的标志，通过设置标志的值终止线程;

public class ThreadTerminatedDemo01 extends Thread{
    public volatile boolean exit = false;

    @Override
    public void run() {
        while (!exit) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

interrupt() 方法中断线程

线程出与阻塞状态：调用interrupt()方法时会抛出InterruptedException异常。阻塞中哪个方法抛出这个异常，通过代码捕获该异常，然后break跳出循环状态，使得有机会结束这个线程的执行。
线程处于为阻塞状态：使用isInterrupt() 判断线程的中断标志位退出循环。当使用interrupt() 方法时，中断标志就会设置为true，和使用自定义的标志控制循环是相同的原理。

public class ThreadTerminatedDemo02 extends Thread{
    @Override
    public void run() {
        // 非阻塞状态下通过判断中断标志来退出
        while (!isInterrupted()) {
            try {
                // 阻塞状态下捕获中断异常来退出
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                // 捕获到异常后执行break跳出循环
                break;
            }
        }
    }
}

stop() 方法终止线程（线程不安全）

程序中直接使用Thread.stop()方法可以强行终止线程，但会有线程不安全问题。当调用Thread.stop()方法后，线程抛出ThreadDeathError异常，并且会释放其持有的所有锁，从而可能导致数据出现不一致的情况。

6. 死锁与死锁避免

6.1 死锁

线程之间由于相互竞争资源或调度不当而同时被阻塞，它们中的一个或全部都在等待某个资源被释放。

public class ThreadDeadLockDemo {
    private static Object r1 = new Object();
    private static Object r2 = new Object();

    public static void main(String[] args) {
        // Thread01
        new Thread(() -> {
            synchronized (r1) {
                try {
                    System.out.println(Thread.currentThread().getName() + " has got r1.");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " is waiting for r2.");
                synchronized (r2) {
                    System.out.println(Thread.currentThread().getName() + " has got r2.");
                }
            }
        }, "Thread01").start();

        // Thread02
        new Thread(() -> {
            synchronized (r2) {
                System.out.println(Thread.currentThread().getName() + " has got r2.");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " is waiting for r1.");
                synchronized (r1) {
                    System.out.println(Thread.currentThread().getName() + " has got r1.");
                }
            }
        }, "Thread02").start();
    }
}

执行结果：

6.2 死锁产生的四个必要条件

互斥：该资源任意一个时刻智能由一个线程占用；

请求保持：一个进程因请求资源而阻塞时不会释放已经获得的资源；

不可剥夺：一个线程已经获得的资源不能被其它线程强行剥夺，只有等使用结束才会被释放；

循环等待：若干进程之间形成一种头尾相接的循环等待资源关系。

6.3 死锁避免

破坏产生死锁的四个必要条件中的一个。

破坏互斥条件：无法破坏。

破坏请求保持条件：线程一次性申请所有的资源。

破坏不可剥夺条件：占用部分资源的线程进一步申请资源时，如果申请不到可以主动释放已占有的资源。

破坏循环等待条件：靠按序申请预防。按某一顺序申请资源，释放资源则反序释放，破坏循环等待条件。

public class BreakDeadLockDemo {
    private static Object r1 = new Object();
    private static Object r2 = new Object();

    public static void main(String[] args) {
        // Thread01
        new Thread(() -> {
            synchronized (r1) {
                try {
                    System.out.println(Thread.currentThread().getName() + " has got r1.");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " is waiting for r2.");
                synchronized (r2) {
                    System.out.println(Thread.currentThread().getName() + " has got r2.");
                }
            }
        }, "Thread01").start();

        // Thread02
        new Thread(() -> {
            synchronized (r1) {
                System.out.println(Thread.currentThread().getName() + " has got r1.");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " is waiting for r1.");
                synchronized (r2) {
                    System.out.println(Thread.currentThread().getName() + " has got r2.");
                }
            }
        }, "Thread02").start();
    }
}

对Thread02线程进行修改后，破坏循环等待条件，从而避免死锁。执行结果如下：

7. 比较sleep()和wait()方法

最大区别：sleep()不会释放锁，wait()方法会释放锁；
两者都可以暂停线程的执行；
sleep()通常被用于暂停执行，wait()通常用于线程间通信/交互；
wait()方法调用后，线程不会自动唤醒，需要其他线程调用notify()/notifyAll()方法。sleep(long timeout)方法或者wait(long timeout)可以指定线程休眠的时间，超时后线程会自动唤醒。

8. 比较run()和start()方法

创建一个线程时需要重写run()方法，调用start()方法后会启动该线程。调用start()方法会执行线程的相应准备工作然后自动执行run()方法的内容，这是真正的多线程工作。执行run()方法会把run()方法当成main线程下的普通方法去执行，并不会再某个线程中执行，不是多线程的工作。

调用start()方法可以启动线程并使该线程进入就绪状态，而执行run()方法只是线程中的一个普通方法调用，仍在main线程里执行。

多线程相关

原文地址：https://www.cnblogs.com/chiaki/p/13515249.html

hmoban主题是根据ripro二开的主题，极致后台体验，无插件，集成会员系统
自学咖网 » 多线程相关

wen 普通

分享到：

多线程相关

1. 进程与线程

2. 并行与并发

3. 线程的生命周期（状态）

4. 线程的创建方式

4.1 继承Thread类

4.2 实现Runnable接口

4.3 实现Callable接口

5. 线程终止的方式

6. 死锁与死锁避免

6.1 死锁

6.2 死锁产生的四个必要条件

6.3 死锁避免

7. 比较sleep()和wait()方法

8. 比较run()和start()方法

wen 普通

相关推荐