Java多线程

已于 2023-02-12 14:57:03 修改
阅读量128 收藏
点赞数
分类专栏： 多线程 文章标签： java jvm servlet Powered by 金山文档
于 2023-02-12 14:10:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73966775/article/details/128991793
版权

  1. java程序，进程，线程，并行，并发的概念

1.1 程序

为完成特定任务、用某种语言编写的一组指令的集

合。即指一段静态的代码，静态对象。

1.2 进程

程序的一次执行过程，或是正在运行的一个程序。

是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期。

·如：运行中的 QQ，运行中的 MP3 播放器程序是静态的，进程是动态的。

·进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区

域。

1.3 线程

进程可进一步细化为线程，是一个程序内部的一条执

行路径。

·若一个进程同一时间并行执行多个线程，就是支持多线程的。

·线程是调度和执行的单位，每个线程拥有独立的运行栈和程序计数器 (pc)，

线程切换的开销小。

·一个进程中的多个线程共享相同的内存单元 / 内存地址空间—它们从同

一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、

高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

1.4 并行

多个 CPU 同时执行多个任务。比如：多个人同时做不同的事。

1.5 并发

一个 CPU（采用时间片）同时执行多个任务。比如：秒杀、多

个人做同一件事。

  1. 线程的运用及优点

2.1 线程在何时使用

1.程序需要同时执行两个或多个任务。

2.程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、

网络操作、搜索等。

3.需要一些后台运行的程序时。

2.2 多线程的优点

以单核 CPU 为例，只使用单个线程先后完成多个任务（调用多个方法），

肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

多线程程序的优点：

1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

2. 提高计算机系统 CPU 的利用率。

3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利

于理解和修改。

3.线程的创建和使用

3.1 线程的创建和启动

Java 语言的 JVM 允许程序运行多个线程，它通过 java.lang.Thread 类来

体现。

Thread 类的特性：

每个线程都是通过某个特定 Thread 对象的 run() 方法来完成操作的，

经常把 run() 方法的主体称为线程体。

线程创建方法：

  1. 继承Thread类

  1. 使用Runnable接口

  1. 实现 Callable 接口（jdk5.0新增）

  1. 使用线程池（jdk5.0）

线程启动：通过该 Thread 对象的 start() 方法来启动这个线程，而非直接调用

run()。

3.2 API中创建线程的两种方式

3.2.1 继承Thread类

1. 创建一个继承于 Thread 类的子类；

2. 重写 Thread 类的 run() 方法 ---> 将此线程的方法声明在 run() 中；

3. 创建 Thread 类的子对象；

4. 通过此对象调用 start()。

// 例子 : 遍历 100 以内的所有的偶数
// 1. 创建一个继承于 Thread 类的子类
class MyThread extends Thread{
// 2. 重写 Thread 类的 run()
@Override
public void run() {
        for(int i = 1;i < 100;i++){
            if(i % 2 == 0){
                System.out.println(i);
 }
 }
}
}
public class ThreadTest {
public static void main(String[] args) {
        // 3. 创建 Thread 类的子对象
        MyThread t1 = new MyThread();
        // 4. 通过此对象调用 start():
        // ①启动当前线程 ②调用当前线程的 run()
        t1.start();
        // 如下操作仍在 main 线程中执行的
        for(int i = 1;i < 100;i++){
            if(i % 2 == 0){
                System.out.println(i + "***main()***");
 }
 }
}
}

注意问题：

1.不能直接通过Thread类的子对象直接调用run()方法

2.

再启动一个线程，不可以还让已经 start() 的线程去执行。会报 IllegalThreadStateException（线程异常）

public class ThreadTest {
public static void main(String[] args) {
        // 3. 创建 Thread 类的子对象
        MyThread t1 = new MyThread();
// 4. 通过此对象调用 start(): ①启动当前线程 ②调用当前线程的 run()
        t1.start();
 // 问题 1: 我们不能通过直接调用 run() 的方式启动线程。
        // t1.run();
        // 问题二 : 再启动一个线程，遍历 100 以内的偶数。不可以还让
已经 start() 的线程去执行。会报 IllegalThreadStateException
        // t1.start();
        // 我们需要重现创建一个线程的对象，去 start().
        MyThread t2 = new MyThread();
        t2.start();
        // 如下操作仍在 main 线程中执行的
        for (int i = 1; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().
getName() + ":" + i + "***main()***");
 }
 }
}
}
3.2.1.1 Thread类的有关方法

1.start()：启动当前线程，执行当前线程的 run()。

2.run()：通常需要重写 Thread 类中的此方法，将创建的线程要执行的

操作声明在此方法中。

3.currentThread()：静态方法，返回当前代码执行的线程。

4.getName()：获取当前线程的名字。

5.setName()：设置当前线程的名字。

6.yield()：释放当前 CPU 的执行权。

7.join()：在线程 a 中调用线程 b 的 join(), 此时线程 a 就进入阻塞状态，

直到线程 b 完全执行完以后，线程 a 才结束阻塞状态。

8.stop()：已过时。当执行此方法时，强制结束当前线程。

9.sleep(long millitime)：让当前线程“睡眠”指定时间的 millitime 毫秒。

在指定的 millitime 毫秒时间内，当前线程是阻塞状态的，调用 sleep 不会释放对象锁。

10.isAlive()：返回 boolean，判断线程是否还活着

public class ThreadModeTest {
public static void main(String[] args) {
        HelloThread h1 = new HelloThread("Thread : 1");
// h1.setName(" 线程一 ");
h1.start();
// 给主线程命名
Thread.currentThread().setName(" 主线程 ");
for(int i = 0;i < 100; i++){
        if(i % 2 == 0){
            System.out.println(Thread.currentThread().getName() 
+ ":" + i);
 }
        if(i == 20){
            try {
                h1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
 }
 }
 }
        System.out.println(h1.isAlive());
}
}
3.2.1.2 线程的调度和优先级

  1. 线程调度

Java 的调度方法：

同优先级线程组成先进先出队列（先到先服务），使用时间片策略；

对高优先级，使用优先调度的抢占式策略。

  1. 线程的优先级

线程的优先级等级：

- MAX_PRIORITY：10

- MIN _PRIORITY：1

- NORM_PRIORITY：5 ---> 默认优先级

涉及的方法：

- getPriority() ：返回线程优先值。

- setPriority(intnewPriority) ：改变线程的优先级。

说明 : 高优先级的线程要抢占低优先级线程 cpu 的执行权。但是只是从

概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优

先级的线程执行完以后，低优先级的线程才会被执行。

3.2.2 实现Runnable接口

1. 创建一个实现了 Runnable 接口的类；

2. 实现类去实现 Runnable 中的抽象方法 :run()；

3. 创建实现类的对象；

4. 将此对象作为参数传递到 Thread 类的构造器中，创建 Thread 类的对

象；

5. 通过 Thread 类的对象调用 start()；

// 1. 创建一个实现了 Runnable 接口的类
class MThread implements Runnable{
// 2. 实现类去实现 Runnable 中的抽象方法 :run()
@Override
public void run() {
        for(int i = 0;i < 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().
getName() + ":" + i);
 }
 }
}
}
public class ThreadTest1 {
public static void main(String[] args) {
        // 3. 创建实现类的对象
        MThread m1 = new MThread();
 // 4. 将此对象作为参数传递到 Thread 类的构造器中，创建
Thread 类的对象
        Thread t1 = new Thread(m1);
 // 5. 通过 Thread 类的对象调用 start(): ①启动线程 ②调用当前
线程的 run() --> 调用了 Runnable 类型的 target 的 run()
        t1.start();
        // 再启动一个线程，遍历 100 以内的偶数
        Thread t2 = new Thread(m1);
        t2.setName(" 线程 2");
        t2.start();
}
}

3.2.3 继承方式和实现方式的联系与区别

比较创建线程的两种方式

开发中：优先选择：实现 Runnable 接口的方式。

原因：1. 实现的方式没有类的单继承性的局限性。

2. 实现的方式更适合来处理多个线程有共享数据的情况。

联系：public class Thread implements Runnable。

相同点：两种方式都需要重写 run(), 将线程要执行的逻辑声明在 run()

中。

补充：

Java 中的线程分为两类：一种是守护线程，一种是用户线程。

·它们在几乎每个方面都是相同的，唯一的区别是判断 JVM 何时离开。

·守护线程是用来服务用户线程的，通过在 start() 方法前调用 **thread.

setDaemon(true)** 可以把一个用户线程变成一个守护线程。

· Java 垃圾回收就是一个典型的守护线程。

·若 JVM 中都是守护线程，当前 JVM 将退出。

·形象理解：兔死狗烹，鸟尽弓藏

4.线程的生周期

JDK 中用 Thread.State 类定义了线程的几种状态：

新建：当一个 Thread 类或其子类的对象被声明并创建时，新生的线程

对象处于新建状态。

就绪：处于新建状态的线程被 start() 后，将进入线程队列等待 CPU 时

间片，此时它已具备了运行的条件，只是没分配到 CPU 资源。

运行：当就绪的线程被调度并获得 CPU 资源时 , 便进入运行状态，

run() 方法定义了线程的操作和功能。

阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出

CPU 并临时中止自己的执行，进入阻塞状态。

死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异

常导致结束。

5.线程同步

多个线程执行的不确定性引起执行结果的不稳定。

多个线程对账本的共享，会造成操作的不完整性，会破坏数据

5.1同步代码块处理实现 Runnable的线程安全问题

方式一：同步代码块

synchronized( 同步监视器 ){        
// 需要被同步的代码
}

说明：1. 操作共享数据的代码，即为需要被同步的代码 ---> 不能包含代

码多了，也不能包含代码少了。

2. 共享数据：多个线程共同操作的变量。比如：ticket 就是共享数据。

3. 同步监视器，俗称：锁。任何一个类的对象，都可以来充当锁。

要求：多个线程必须要共用同一把锁。

补充：在实现 Runnable 接口创建多线程的方式中，我们可以考虑使用

this 充当同步监视器。

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方

法声明同步的。

4. 同步的方式，解决了线程的安全问题。--- 好处

操作同步代码时，只能有一个线程参与，其他线程等待。相当于

是一个单线程的过程，效率低。--- 局限性

class Windows1 implements Runnable {
private int ticket = 100;
// Object obj = new Object();
// Dog dog = new Dog();
282 283
@Override
public void run() {
        while (true) {
            synchronized (this) {
// 此时的 this: 唯一的 windows1 的对象 // 方式二 :synchronized (dog) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
 }
                    System.out.println(Thread.currentThread().
getName() + ": 卖票，票号为 : " + ticket);
                    ticket--;
                } else {
                    break;
 }
 }
 }
}
}
public class WindowsTest1 {
public static void main(String[] args) {
        Windows1 w = new Windows1();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName(" 窗口 1");
        t2.setName(" 窗口 2");
        t3.setName(" 窗口 3");
        t1.start();
        t2.start();
        t3.start();
}
}

5.2 同步方法处理实现 Runnable的线程安全问题

1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。

2. 非静态的同步方法，同步监视器是：this；

静态的同步方法，同步监视器是：当前类本身。

class Windows3 implements Runnable {
private int ticket = 100;
@Override
public void run() {
        while (true) {
            show();
 }
}
public synchronized void show() { // 同步监视器：this
// synchronized (this){
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
 }
            System.out.println(Thread.currentThread().getName() 
+ ": 卖票，票号为 : " + ticket);
            ticket--;
 }
// }
}
}
public class WindowsTest3 {
public static void main(String[] args) {
        Windows3 w3 = new Windows3();
        Thread t1 = new Thread(w3);
        Thread t2 = new Thread(w3);
        Thread t3 = new Thread(w3);
        t1.setName(" 窗口 1");
        t2.setName(" 窗口 2");
        t3.setName(" 窗口 3");
        t1.start();
        t2.start();
        t3.start();
}
}

5.3 同步代码块处理继承 Thread 类的线程安全问题

class Windows extends Thread {
private static int ticket = 100;
private static Object obj = new Object();
@Override
public void run() {
        while (true) {
 // 正确的
//            synchronized (obj) {
            synchronized (Windows.class) { 
 // Class clazz = Windows.class
 // 错误的，因为此时 this 表示的是 t1,t2,t3 三个对象
//                synchronized (this) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
 }
                    System.out.println(getName() + ": 卖 票， 票
号为 : " + ticket);
                    ticket--;
                } else {
                    break;
 }
 }
 }
}
}
public class WindowsTest2 {
public static void main(String[] args) {
        Windows t1 = new Windows();
        Windows t2 = new Windows();
        Windows t3 = new Windows();
        t1.setName(" 窗口 1");
        t2.setName(" 窗口 2");
        t3.setName(" 窗口 3");
        t1.start();
        t2.start();
        t3.start();
}
}

5.4 同步方法处理继承 Thread 类的线程安全问题

class Windows4 extends Thread {
private static int ticket = 100;
@Override
public void run() {
        while (true) {
            show();
 }
}
     // 同步监视器：Window4.class
private static synchronized void show() {
    // 同步监视器：t1,t2,t3。此种解决方式是错误的
    // private synchronized void show(){ 
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
 }
            System.out.println(Thread.currentThread().getName() 
+ "：卖票，票号为：" + ticket);
            ticket--;
 }
}
}
public class WindowsTest4 {
public static void main(String[] args) {
        Windows4 t1 = new Windows4();
        Windows4 t2 = new Windows4();
        Windows4 t3 = new Windows4();
        t1.setName(" 窗口 1");
        t2.setName(" 窗口 2");
        t3.setName(" 窗口 3");
        t1.start();
        t2.start();
        t3.start();
}
}

5.5 线程安全的单例模式之懒汉式

使用同步机制将单例模式中的懒汉式改写为线程安全的。

public class BankTest {
}
class Bank {
private Bank() {
}
private static Bank instance = null;
public static Bank getInstance() {
// 方式一：效率稍差
        // 快捷键 :Alt+Shift+Z
// synchronized (Bank.class) {
//        if(instance == null){
//            instance = new Bank();
/ }
//        return instance;
// }
        // 方式二：效率较高
        if (instance == null) {
            synchronized (Bank.class) {
                if (instance == null) {
                    instance = new Bank();
 }
 }
 }
        return instance;
}
}

5.6 死锁

1. 死锁的理解：不同的线程分别占用对方需要的同步资

源不放弃，都在等待对方放弃自己需要的同步资源，就

形成了线程的死锁。

2. 说明：

出现死锁后，不会出现异常，不会出现提示，只是

所有的线程都处于阻塞状态，无法继续。

我们使用同步时，要避免出现死锁。

class A {
public synchronized void foo(B b) {
        System.out.println(" 当前线程名 : " + Thread.currentThread().
getName() + " 进入了 A 实例的 foo 方法 "); // ①
        try {
            Thread.sleep(200);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
 }
        System.out.println(" 当前线程名 : " + Thread.currentThread().
getName() + " 企图调用 B 实例的 last 方法 "); // ③
        b.last();
}
public synchronized void last() {
        System.out.println(" 进入了 A 类的 last 方法内部 ");
}
}
class B {
public synchronized void bar(A a) {
        System.out.println(" 当前线程名 : " + Thread.currentThread().
getName() + " 进入了 B 实例的 bar 方法 "); // ②
        try {
            Thread.sleep(200);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
 }
        System.out.println(" 当前线程名 : " + Thread.currentThread().
getName() + " 企图调用 A 实例的 last 方法 "); // ④
        a.last();
}
public synchronized void last() {
        System.out.println(" 进入了 B 类的 last 方法内部 ");
}
}
public class DeadLock implements Runnable {
A a = new A();
B b = new B();
public void init() {
        Thread.currentThread().setName(" 主线程 ");
        // 调用 a 对象的 foo 方法
        a.foo(b);
        System.out.println(" 进入了主线程之后 ");
}
public void run() {
        Thread.currentThread().setName(" 副线程 ");
        // 调用 b 对象的 bar 方法
        b.bar(a);
        System.out.println(" 进入了副线程之后 ");
}
public static void main(String[] args) {
        DeadLock dl = new DeadLock();
        new Thread(dl).start();
        dl.init();
}
}

5.7 Lock 锁方式解决线程安全问题

java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对 Lock 对象加锁，线程开始访问共享资源之前应先获得 Lock 对象。

ReentrantLock 类实现了 Lock ，它拥有与 synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是 ReentrantLock，可以显式加锁、释放锁。

从 JDK 5.0 开始，Java 提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用 Lock 对象充当。

解决线程安全问题的方式三：lock 锁 ---》JDK5.0 新增。

注意：如果同步代码有异常，要将 unlock() 写入 finally 语句块。

1. 面试题：synchronized 与 Lock 的异同？

相同：二者都可以解决线程安全问题；

不同：synchronized 机制在执行完相应的同步代码以后，自动的释放同步监视器。

Lock 需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）。

2. 优先使用顺序：

Lock

·同步代码块（已经进入了方法体，分配了相应资源）

·同步方法（在方法体之外）。

class Windows implements Runnable {
private int ticket = 100;
// 1. 实例化 ReentrantLock
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
        while (true) {
            try {
                // 2. 调用锁定方法：lock()
                lock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
 }
                    System.out.println(Thread.currentThread().
getName() + ": 售票，票号为 : " + ticket);
                    ticket--;
                } else {
                    break;
 }
            } finally {
                // 3. 调用解锁方法：unlock()
                lock.unlock();
 }
 }
}
}
296 297
public class LockTest {
public static void main(String[] args) {
        Windows w = new Windows();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName(" 窗口 1");
        t2.setName(" 窗口 2");
        t3.setName(" 窗口 3");
        t1.start();
        t2.start();
        t3.start();
}
}

5.8 线程的通信

线程通信的例子：使用两个线程打印 1-100。线程 1， 线程 2 交替打印。

涉及到的三个方法：

wait()：一旦执行此方法，当前线程就进入阻塞状态，

并释放同步监视器。

notify()：一旦执行此方法，就会唤醒被 wait 的一个

线程。如果有多个线程被 wait，就唤醒优先级高的那个。

notifyAll()：一旦执行此方法，就会唤醒所有被 wait

的线程。

说明：

1.wait()，notify()，notifyAll() 三个方法必须使用在同

步代码块或同步方法中。

2.wait()，notify()，notifyAll() 三个方法的调用者必须

是同步代码块或同步方法中的同步监视器。否则，会出

现 IllegalMonitorStateException 异常。

3.wait()，notify()，notifyAll() 三个方法是定义在 java.

lang.Object 类中。

class Number implements Runnable {
private int number = 1;
public Object obj = new Object();
@Override
public void run() {
        while (true) {
            synchronized (obj) {
                obj.notify();
300 301
                if (number <= 100) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
 }
                    System.out.println(Thread.currentThread().
getName() + ":" + number);
                    number++;
                    try {
//                     使得调用如下 wait() 方法的线程进入阻塞状态
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
 }
                } else {
                    break;
 }
 }
 }
}
}
public class CommunicationTest {
public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);
        t1.setName(" 线程 1");
        t2.setName(" 线程 2");
        t1.start();
        t2.start();
}
}

5.9 sleep() 和 wait() 的异同

1. 相同点：一旦执行方法，都可以使得当前的线程进入

阻塞状态。

2. 不同点：

2.1. 两个方法声明的位置不同：

Thread 类中声明 sleep()

Object 类中声明 wait()

2.2. 调用的要求不同：

sleep() 可以在任何需要的场景下调用。

wait() 必须使用在同步代码块或同步方法中。

2.3. 关于是否释放同步监视器：如果两个方法都使用在

同步代码块或同步方法中，sleep() 不会释放锁，wait() 会

释放锁

6. JDK5.0 新增线程创建方式

6.1 创建多线程的方式三：实现 Callable 接口

如何理解实现 Callable 接口的方式创建多线程比实现Runnable 接口创建多线程方式强大？

1. call() 可以有返回值的。

2. call() 可以抛出异常，被外面的操作捕获，获取异常的信息。

3. Callable 是支持泛型的。

4. 需要借助 FutureTask 类，比如获取返回结果。

Future 接口

可以对具体 Runnable、Callable 任务的执行结果进行取消、查询是否完成、获取结果等。

FutrueTask 是 Futrue 接口的唯一的实现类。

FutureTask 同时实现了 Runnable, Future 接口。

它既可以作为 Runnable 被线程执行，又可以作为 Future 得到Callable 的返回值。

//1. 创建一个实现 Callable 的实现类
class NumThread implements Callable {
// 2. 实现 call 方法，将此线程需要执行的操作声明在 call() 中
@Override
public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
 }
 }
        return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
        // 3. 创建 Callable 接口实现类的对象
        NumThread numThread = new NumThread();
 // 4. 将此 Callable 接口实现类的对象作为传递到 FutureTask 构
造器中，创建 FutureTask 的对象
        FutureTask futureTask = new FutureTask(numThread);
 // 5. 将 FutureTask 的对象作为参数传递到 Thread 类的构造器
中，创建 Thread 对象，并调用 start()
        new Thread(futureTask).start();
        try {
 // 6. 获取 Callable 中 call 方法的返回值
            // get() 返回值即为 FutureTask 构造器参数 Callable 实现
类重写的 call() 的返回值。
            Object sum = futureTask.get();
            System.out.println(" 总和为 :" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
 }
}
}

6.2 创建多线程的方式四：使用线程池

6.2.1 背景：

经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

6.2.2思路：

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

6.2.3好处：

1.提高响应速度（减少了创建新线程的时间）

2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）便于线程管理

corePoolSize：核心池的大小

maximumPoolSize：最大线程数

keepAliveTime：线程没有任务时最多保持多长时间后会终止

6.2.4方法

Java提供Executor接口来执行线程池中的任务，提供ExecutorService接口来管理和控制任务。ExecutorService是Executor子接口。

　　为了创建一个Executor对象，可以使用Executors类中的静态方法

  • newFixedThreadPool(int)：在线程池中创建可重用的固定数目的线程。如果线程完成了任务的执行，它可以被重新使用以执行另外一个任务。如果线程池中所有的线程都不是处于空闲状态，而且有任务在等待执行，那么在关闭之前，如果由于一个错误终止了一个线程，就会创建一个新线程来替换它

  • newCachedThreadPool()：如果线程池中所有的线程都不是处于空闲状态，而且有任务在等待执行，会创建一个新线程。如果缓冲池中的线程在60秒内都没有被使用就该终止它。对许多小任务而言，一个缓冲池已经足够

  • newSingleThreadExecutor():创建一个只有一个线程的线程池。

  • newScheduledThreadPool(int corePoolSize):创建具有指定线程数的线程池，可以在指定延迟后执行任务。corePoolSize指池中保存的线程数，即使线程是空闲的也保存在池中

  • newSingleThreadScheduledExecutor():创建一个只有一个线程的线程池,可以在指定延迟后执行任务

  • newWorkStealingPool(int parallelism):创建持有足够的线程的线程池来支持给定的并行级别，该方法会使用多个队列来减少竞争。newWorkStealingPool()是为简化版本，以机器CPU数量作为参数传入。

class NumberThread implements Runnable {
@Override
public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().
getName() + ":" + i);
 }
 }
}
}
class NumberThread1 implements Runnable {
@Override
public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().
getName() + ":" + i);
 }
 }
}
}
public class ThreadPool {
public static void main(String[] args) {
        // 1. 提供指定线程数量的线程池
        ExecutorService service = Executors.
newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) 
service;
        // 设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();
 // 2. 执行指定的线程的操作。需要提供实现 Runnable 接口或
Callable 接口实现类的对象
        service.execute(new NumberThread()); 
        // 适合适用于 Runable
        service.execute(new NumberThread1()); 
        // 适合适用于 Runable
//        service.submit(Callable callable); // 适合适用于 Callable
        // 3. 关闭连接池
        service.shutdown();
}
}

罗小黑的橙子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
java多线程（超详细）
zdl66的博客
08-14 9万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
【Java系列】深入解析Java多线程
颜淡慕潇
05-09 2万+
Java多线程是提高程序并发性和响应能力的重要手段，需要掌握多线程的实现方式、同步机制、线程之间的通信机制等，以确保多线程程序的正确性和稳定性。
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
java多线程使用教程
鹏鹏2077
04-25 5205
本教程介绍了Java多线程的基本知识和使用方法，包括创建线程、实现Runnable接口、继承Thread类、线程同步、线程间通信和线程池等。多线程技术可以提高程序的并发处理能力和响应速度，但同时也带来了线程安全和同步等问题，需要合理使用同步机制来保证线程安全。使用Java提供的Lock接口可以实现更加灵活和精细的线程同步。线程间通信可以使用wait()、notify()和notifyAll()方法来实现。线程池机制可以重用线程，提高了线程的利用率和效率。掌握了这些知识，可以使用Java实现高效、安全、可靠的
Java 多线程：彻底搞懂线程池
热门推荐
孙强 Jimmy 的博客
07-09 18万+
熟悉Java多线程编程的同学都知道，当我们线程创建过多时，容易引发内存溢出，因此我们就有必要使用线程池的技术了。
JAVA多线程是什么
qq_45022104的博客
08-31 3990
一、 什么是多线程： 我们现在所使用操作系统都是多任务操作系统(早期使用的DOS操作系统为单任务操作系统)，多任务操作指在同一时刻可以同时做多件事(可以同时执行多个程序)。 多进程:每个程序都是一个进程，在操作系统中可以同时执行多个程序,多进程的目的是为了有效的使用CPU资源，每开一个进程系统要为该进程分配相关的系统资源(内存资源) 多线程:线程是进程内部比进程更小的执行单元(执行流|程序片段),每个线程完成一个任务,每个进程内部包含了多个线程每个线程做自己的事情，在进程中的所有线程共享该进程的资源； 主
java多线程嵌套_Java多线程进阶
weixin_36002897的博客
02-16 4125
需要理解锁是什么意思?首先是发生在多线程的情况下;线程a,线程b,共享资源share例如,share的资源一次只能被一个对象操作,这时候需要一个东西来标识(也叫监视器)出来表明该资源已经有人(指的是线程)在使用了,请还要使用的人(指的是线程)进入等待(线程等待池/队列);怎么实现呢?synchronized关键字,配合一个唯一的东西,可以是类.class,也可以是对象本身;但注意的是必须是一个引用...
编程必备：JAVA多线程详解
拾一二的博客
06-14 6862
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java 多线程的应用场景
才哈哈的博客主页
05-01 1万+
电影院新片首映，观影人数大量增加，为提高日营业额，线下售票窗口由原单窗口调整为3窗口，设计一段简单的程序模拟该售票过程。
Java多线程详解及示例
最新发布
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程编程技术
03-26
《Java多线程编程核心技术》建议猿友们读两遍，因为其写得没有那么抽象，第一遍有些概念不是很理解，可以先跳过并记录起来，第一遍阅读的目的主要是了解整个架构。第二遍再慢慢品味，并贯穿全部是指点来思考，并将...
java多线程
05-02
Java多线程
Java多线程实现同时输出
09-02
主要介绍了Java多线程实现同时打印的相关资料,需要的朋友可以参考下
java多线程处理大数据
07-09
java多线程处理大数据，可根据配置的线程数，任务去调度处理
Java多线程知识点总结
08-19
该文档总结了Java多线程相关的知识点，分享给大家，简单易懂！
Java多线程读取大文件
12-22
为了提高速度，自然还得用上多线程技术。 　接下来介绍一下实现思路以及相关的知识点。 　内容 　一、对文件分区 　为了充分利用多线程读取，需要把文件划分成多个区域，供每个线程读取。那么需要有一个算法来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值