Java中的线程

已于 2022-10-08 21:19:46 修改
阅读量589 收藏 5
点赞数
分类专栏： # Java基础 文章标签： java 开发语言 jvm
于 2022-07-05 10:48:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52078336/article/details/125615209
版权

文章目录

线程简要

什么是线程：

  • 线程(thread)是一个程序内部的一条执行路径。
  • 我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径。
  • 程序中如果只有一条执行路径，那么这个程序就是单线程的程序。
  • 多线程是指从软硬件上实现多条执行流程的技术。
  • 应用：即时通讯软件、购票系统、网盘数据传输；

多线程的创建

方式一：继承Thread类

Thread类：

  • Java是通过java.lang.Thread 类来代表线程的。
  • 按照面向对象的思想，Thread类应该提供了实现多线程的方式。

步骤：

  • 定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法
  • 创建MyThread类的对象
  • 调用线程对象的start()方法启动线程（启动后还是执行run()方法的）

优缺点：

  • 优点：编码简单
  • 缺点：线程类已经继承Thread，无法继承其他类，不利于扩展。

测试代码：

package cn.edu.njust.thread;

/* 测试类，体验线程
 * 掌握多线程的创建方式一：继承Thread类
 * */
public class Demo01 {
    public static void main(String[] args) {
        // 1.创建自己的线程对象
        Thread t1 = new MyThread();
        // 2.调用start方法启动线程
        t1.start();
        /* 说明
         * 调用start方法之后，其实就有多线程了
         * main方法有一个线程（主线程），MyThread也有一个线程
         * */

        // 设置一个主线程的任务，方便比较
        for (int i = 0; i < 10; i++) {
            System.out.println("main方法的主线程，执行第" + i + "次");
        }
    }
}

/*
MyThread线程第0次输出
main方法的主线程，执行第0次
main方法的主线程，执行第1次
MyThread线程第1次输出
main方法的主线程，执行第2次
MyThread线程第2次输出
main方法的主线程，执行第3次
MyThread线程第3次输出
main方法的主线程，执行第4次
MyThread线程第4次输出
main方法的主线程，执行第5次
main方法的主线程，执行第6次
main方法的主线程，执行第7次
MyThread线程第5次输出
main方法的主线程，执行第8次
MyThread线程第6次输出
main方法的主线程，执行第9次
MyThread线程第7次输出
MyThread线程第8次输出
MyThread线程第9次输出

*/

MyThread类

package cn.edu.njust.thread;

/* 创建自己的线程类
 * 创建方式一：继承Thread类
 * */
public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("MyThread线程第" + i + "次输出");
        }
    }
}

注意事项：

  • 不能使用run方法启动多线程，这样做依然是单线程的调用；
  • 不要将主线程的功能部分放在其他线程的start方法之前，这样相当于其他线程还没有启动，不会带来多线程的效果；

方式二：实现Runnable接口

步骤：

  • 定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
  • 创建MyRunnable任务对象
  • 把MyRunnable任务对象交给Thread处理。
  • 调用线程对象的start()方法启动线程。

Thread的构造器：

构造器说明
public Thread(String name)可以为当前线程指定名称
public Thread(Runnable target)封装Runnable对象成为线程对象
public Thread(Runnable target ，String name )封装Runnable对象成为线程对象，并指定线程名称

优缺点：

  • 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
  • 缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

代码样例：

package cn.edu.njust.runnable;

public class RunnableTest {
    // 学会使用Runnable类实现自己的接口
    public static void main(String[] args) {
        // 1.创建一个任务对象
        Runnable myRunnable = new MyRunnable();
        // 2.将任务对象交给线程对象
        Thread thread = new Thread(myRunnable);
        // 3.启动线程
        thread.start();

        // 主线程输出
        for (int i = 0; i < 10; i++) {
            System.out.println("RunnableTest的主线程完成了第" + i + "次输出");
        }
    }
}

/*
RunnableTest的主线程完成了第0次输出
MyRunnable类的线程执行了第0次循环
RunnableTest的主线程完成了第1次输出
RunnableTest的主线程完成了第2次输出
RunnableTest的主线程完成了第3次输出
RunnableTest的主线程完成了第4次输出
RunnableTest的主线程完成了第5次输出
MyRunnable类的线程执行了第1次循环
RunnableTest的主线程完成了第6次输出
MyRunnable类的线程执行了第2次循环
MyRunnable类的线程执行了第3次循环
RunnableTest的主线程完成了第7次输出
MyRunnable类的线程执行了第4次循环
MyRunnable类的线程执行了第5次循环
RunnableTest的主线程完成了第8次输出
MyRunnable类的线程执行了第6次循环
RunnableTest的主线程完成了第9次输出
MyRunnable类的线程执行了第7次循环
MyRunnable类的线程执行了第8次循环
MyRunnable类的线程执行了第9次循环

*/

MyRunnable类：

package cn.edu.njust.runnable;

/* 创建自己的线程
 * 使用方式二创建多线程 -- Runnable接口的实现类
 * */
public class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("MyRunnable类的线程执行了第" + i + "次循环");
        }
    }
}

使用匿名内部类实现方式二：

package cn.edu.njust.runnable;

public class RunnableTest02 {
    // 使用匿名内部类实现方式二
    // 不需要额外创建类
    public static void main(String[] args) {
        /*Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("匿名内部类线程执行了第" + i + "次循环");
                }
            }
        };
        Thread t = new Thread(target);
        t.start();

        下面简化代码：
        */

        /*new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("匿名内部类线程执行了第" + i + "次循环");
                }
            }
        }).start();

        再次简化代码
        */

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("匿名内部类线程执行了第" + i + "次循环");
            }
        }).start();

        // 主线程输出
        for (int i = 0; i < 10; i++) {
            System.out.println("RunnableTest的主线程完成了第" + i + "次输出");
        }
    }
}
/*
RunnableTest的主线程完成了第0次输出
RunnableTest的主线程完成了第1次输出
RunnableTest的主线程完成了第2次输出
RunnableTest的主线程完成了第3次输出
RunnableTest的主线程完成了第4次输出
RunnableTest的主线程完成了第5次输出
RunnableTest的主线程完成了第6次输出
匿名内部类线程执行了第0次循环
匿名内部类线程执行了第1次循环
匿名内部类线程执行了第2次循环
匿名内部类线程执行了第3次循环
匿名内部类线程执行了第4次循环
匿名内部类线程执行了第5次循环
匿名内部类线程执行了第6次循环
匿名内部类线程执行了第7次循环
匿名内部类线程执行了第8次循环
匿名内部类线程执行了第9次循环
RunnableTest的主线程完成了第7次输出
RunnableTest的主线程完成了第8次输出
RunnableTest的主线程完成了第9次输出

*/

方式三：实现Callable接口

简介：

  • JDK1.5开始提供了这种方式；
  • 这种方式的优点是：可以得到线程执行的结果。

实现步骤(利用Callable、FutureTask接口实现)：

  • 得到任务对象

    • 定义类实现Callable接口，重写call方法，封装要做的事情。
    • 用FutureTask把Callable对象封装成线程任务对象。

  • 线程任务对象交给Thread处理。

  • 调用Thread的start方法启动线程，执行任务

  • 线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

FutureTask常用API：

方法名称说明
public FutureTask<>(Callable call)把Callable对象封装成FutureTask对象。
public V get() throws Exception获取线程执行call方法返回的结果。

优缺点：

  • 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
  • 可以在线程执行完毕后去获取线程执行的结果。
  • 缺点：编码复杂一点。

代码演示：

package cn.edu.njust.callable;

import java.util.concurrent.*;

/* 学会使用Callable实现多线程的创建
 *
 * */
public class CallableTest {
    public static void main(String[] args) {
        // 1.创建任务对象
        Callable<String> callable = new MyCallable(50);
        // 2.将 Callable 对象交给 FutureTask 对象
        // FutureTask实现了Runnable接口
        FutureTask<String> ft = new FutureTask<>(callable);
        // 3.将该对象交给线程对象
        Thread thread = new Thread(ft);
        // 4.启动线程
        thread.start();

        // 再创建一个线程
        Callable<String> callable1 = new MyCallable(100);
        FutureTask<String> ft1 = new FutureTask<>(callable);
        Thread thread1 = new Thread(ft1);
        thread1.start();

        // 5.利用get方法接收线程任务的结果
        try {
            String rs1 = ft.get();
            System.out.println("线程任务1的结果是sum = " + rs1);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        try {
            String rs2 = ft.get();
            System.out.println("线程任务2的结果是sum = " + rs2);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        // 主线程输出
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程完成了第" + i + "次输出");
        }
    }
}

MyCallable类：

package cn.edu.njust.callable;

import java.util.concurrent.Callable;

/*
 * 实现Callable接口
 * 该接口为泛型接口
 * 应该声明任务的数据类型
 * */
public class MyCallable implements Callable<String > {
    // 设置一个前n项和的线程任务
    private int n;

    public MyCallable() {
    }

    public MyCallable(int n) {
        this.n = n;
    }

    public int getN() {
        return n;
    }

    public void setN(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i < this.n; i++) {
            sum += i;
        }
        return "子线程任务执行结果sum = " + sum;
    }
}

三种方式的对比

方式优点缺点
继承Thread类编程比较简单，可以直接使用Thread类中的方法扩展性较差，不能再继承其他的类，不能返回线程执行的结果
实现Runnable接口扩展性强，实现该接口的同时还可以继承其他的类。编程相对复杂，不能返回线程执行的结果
实现Callable接口扩展性强，实现该接口的同时还可以继承其他的类。可以得到线程执行的结果编程相对复杂

Thread的常用方法

说明：

  • Thread常用方法：获取线程名称getName()、设置名称setName()、获取当前线程对象currentThread()。
  • 至于Thread类提供的诸如：yield、join、interrupt、不推荐的方法 stop 、守护线程、线程优先级等线程的控制方法，在开发中很少使用，这些方法会在高级篇以及后续需要用到的时候再为大家讲解。
  • 当线程很多时，需要根据线程的名称来区分线程；

常用API

方法名称说明
String getName()获取当前线程的名称，默认线程名称是Thread-索引
void setName(String name)将此线程的名称更改为指定的名称，通过构造器也可以设置线程名称
public static Thread currentThread()：返回对当前正在执行的线程对象的引用
public Thread(String name)可以为当前线程指定名称
public Thread(Runnable target)封装Runnable对象成为线程对象
public Thread(Runnable target ，String name )封装Runnable对象成为线程对象，并指定线程名称
public static void sleep(long time)让当前线程休眠指定的时间后再继续执行，单位为毫秒。

MyThreadTwo类：

package cn.edu.njust.thread;

/* 创建自己的线程类
 * 创建方式一：继承Thread类
 * */
public class MyThreadTwo extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "输出" + i);
        }
    }
}


package cn.edu.njust.thread;

public class Demo02 {
    public static void main(String[] args) {
        Thread t1 = new MyThreadTwo();
        // t1.setName("线程1");
        t1.start();

        Thread t2 = new MyThreadTwo();
        // t2.setName("线程2");
        t2.start();


        // 获取主线程信息
        // Thread mThread = Thread.currentThread();
        // System.out.println("主线程名字：" + mThread.getName());
        // 主线程任务
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "输出" + i);
        }
    }
}

/*
Thread-0输出0
main输出0
Thread-1输出0
main输出1
Thread-0输出1
main输出2
Thread-1输出1
Thread-1输出2
Thread-1输出3
Thread-1输出4
Thread-1输出5
Thread-1输出6
Thread-1输出7
Thread-1输出8
main输出3
Thread-0输出2
Thread-0输出3
Thread-0输出4
Thread-0输出5
Thread-0输出6
main输出4
Thread-1输出9
main输出5
main输出6
main输出7
main输出8
main输出9
Thread-0输出7
Thread-0输出8
Thread-0输出9

*/

总结

方法名称说明
String getName()获取当前线程的名称，默认线程名称是Thread-索引
void setName(String name)设置线程名称
public static Thread currentThread()：返回对当前正在执行的线程对象的引用
public static void sleep(long time)让线程休眠指定的时间，单位为毫秒。
public void run()线程任务方法
public void start()线程启动方法
构造器说明
public Thread(String name)可以为当前线程指定名称
public Thread(Runnable target)把Runnable对象交给线程对象
public Thread(Runnable target ，String name )把Runnable对象交给线程对象，并指定线程名称

注意：一般开发中不会自己给线程取名字；

线程相关问题

线程安全

出现原因：多个线程对同一组数据同时进行操作，导致实际上不符。

示例：生活中购票系统，银行取钱等场景，都可能出现这种类似的问题；

线程同步

线程同步：为解决安全问题而生；

线程同步核心思想：加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。

加锁方式一：同步代码块

作用：把出现线程安全问题的核心代码给上锁；

原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进入执行；

synchronized(同步锁对象){
	操作共享资源的代码(核心代码);
}

注意：同步锁对象，必须是同一个。其实没有实际意义，就是一个代表。

锁对象的规范要求：

  • 规范上：建议使用共享资源作为锁对象。
  • 对于实例方法建议使用this作为锁对象。
  • 对于静态方法建议使用字节码（类名.class）对象作为锁对象。
// 对于实例方法，标准的直接使用this当🔒
synchronized(this){
	操作共享资源的代码(核心代码);
}

// 对于静态方法，通常使用 类名.class 做为🔒
synchronized(ClassName.class){
	操作共享资源的代码(核心代码);
}

加锁方式二：同步方法

作用：把出现线程安全问题的核心方法给上锁。
原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

格式：

修饰符 synchronized 返回值类型 方法名称(形参列表) {	
	操作共享资源的代码
}

同步方法底层原理:

  • 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
  • 如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！
  • 如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

加锁方式三：LOCK锁

简要：

  • 为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便。
  • Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。
  • Lock是接口不能直接实例化，这里采用它的**实现类ReentrantLock**来构建Lock锁对象。
方法名称说明
public ReentrantLock()获得Lock锁的实现类对象

常用API：

方法名称说明
void lock()获得锁
void unlock()释放锁

一般格式：

	LOCK.lock();	//上锁
	try{
		// 核心代码块
	}finally{
		LOCK.unlock();	// 解锁
	}

线程通信

简要：所谓线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。

线程通信的前提：线程通信通常是在多个线程操作同一个共享资源的时候需要进行通信，且要保证线程安全。

Object类的等待和唤醒方法：

方法名称说明
void wait()让当前线程等待并释放所占锁，直到另一个线程调用notify()方法或 notifyAll()方法
void notify()唤醒正在等待的单个线程
void notifyAll()唤醒正在等待的所有线程

注意：上述方法应该使用当前同步锁对象进行调用。

代码演示：

测试代码

package cn.edu.njust.threadcom;

public class Demo01 {
    // 了解线程通信的流程
    public static void main(String[] args) {
        // 1.创建账户对象
        Account acc = new Account("ICBC-110", 0);

        // 2.创建两个用户取钱进程
        new DrawThread(acc, "周润发").start();
        new DrawThread(acc, "周星驰").start();

        // 3.创建三个存钱线程
        new DepositThread(acc, "马云").start();
        new DepositThread(acc, "比尔盖茨").start();
        new DepositThread(acc, "马克龙").start();
    }
}
/*

*/

Account类：

package cn.edu.njust.threadcom;

public class Account {
    private String carId;
    private double money;

    public Account() {
    }

    public Account(String carId, double money) {
        this.carId = carId;
        this.money = money;
    }

    public String getCarId() {
        return carId;
    }

    public void setCarId(String carId) {
        this.carId = carId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    /**
     * 取钱业务逻辑
     * @param money 取钱数
     */
    public synchronized void drawMoney(double money){
        try {
            // 获取当前线程用户
            String name = Thread.currentThread().getName();
            if (this.money >= money) {
                // 可以取钱
                this.money -= money;
                System.out.println(name + "取钱" + money + "成功");
                // 假设一次性将钱全部取出，接下来唤醒其他线程
                this.notifyAll(); // 唤醒所有线程
                this.wait(); // 锁对象，让当前线程进入等待
            } else {
                // 余额不足
                // 唤醒其他线程，等待自己（将自己挂起）
                this.notifyAll(); // 唤醒所有线程
                this.wait(); // 锁对象，让当前线程进入等待
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public synchronized void depositMoney(double money) {
        try {
            String name = Thread.currentThread().getName();
            if (this.money == 0) {
                // 存钱
                this.money += money;
                System.out.println(name + "存钱" + money + "成功");
                // 存钱成功，唤醒别人，等待自己
                this.notifyAll(); // 唤醒别人
                this.wait(); // 等待自己
            } else {
                // 有钱不存
                this.notifyAll(); // 唤醒别人
                this.wait(); // 等待自己
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

取钱线程：

package cn.edu.njust.threadcom;

public class DrawThread extends Thread {
    private Account account;

    public DrawThread() {
    }

    public DrawThread(Account account, String name) {
        super(name);
        this.account = account;
    }

    @Override
    public void run() {
        while (true) {
            account.drawMoney(100000);
            try {
                Thread.sleep(3000);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

存钱线程：

package cn.edu.njust.threadcom;

public class DepositThread extends Thread{
    private Account account;

    public DepositThread() {
    }

    public DepositThread(Account account, String name) {
        super(name);
        this.account = account;
    }

    @Override
    public void run() {
        while (true) {
            account.depositMoney(100000);
            try {
                Thread.sleep(3000);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

※ 线程池

什么是线程池：线程池就是一个可以复用线程的技术。

不使用线程池的问题：如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

线程池实现API

谁代表线程池：JDK 5.0起提供了代表线程池的接口：ExecutorService；

创建线程池对象：

  • 方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象；
  • 方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象；

ThreadPoolExecutor构造器的参数说明：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) 
    /*
    参数一：指定线程池的线程数量（核心线程）： corePoolSize
	参数二：指定线程池可支持的最大线程数： maximumPoolSize
	参数三：指定临时线程的最大存活时间： keepAliveTime
	参数四：指定存活时间的单位(秒、分、时、天)： unit
	参数五：指定任务队列： workQueue
	参数六：指定用哪个线程工厂创建线程： threadFactory
	参数七：指定线程忙，任务满的时候，新任务来了怎么办： handler
    */

※临时线程什么时候创建：新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

※什么时候开始拒绝任务：核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。

线程池处理Runnable任务

ThreadPoolExecutor创建线程池对象示例

ExecutorService pools = new ThreadPoolExecutor(3, 
                                               5, 
                                               8, 
                                               TimeUnit.SECONDS, 
                                               new ArrayBlockingQueue<>(6),
                                               Executors.defaultThreadFactory(), 
                                               new ThreadPoolExecutor.AbortPolicy());

ExecutorService的常用方法：

方法名称说明
void execute(Runnable command) 执行任务/命令，没有返回值，一般用来执行 Runnable 任务
Future<T> submit(Callable<T> task) 执行任务，返回未来任务对象获取线程结果，一般拿来执行 Callable 任务
void shutdown() 等任务执行完毕后关闭线程池
List<Runnable> shutdownNow() 立刻关闭，停止正在执行的任务，并返回队列中未执行的任务

新任务拒绝策略：

策略详解
ThreadPoolExecutor.AbortPolicy 丢弃任务并抛出RejectedExecutionException异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy丢弃任务，但是不抛出异常 这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy 抛弃队列中等待最久的任务 然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy 由主线程负责调用任务的run()方法从而绕过线程池直接执行
package cn.edu.njust.threadpool;

import java.util.concurrent.*;

/* 自定义一个线程池对象
 * 测试其特性
 * */
public class Demo01 {
    public static void main(String[] args) {
        // 1.创建线程池对象
        /*int var1,
        int var2,
        long var3,
        TimeUnit var5,
        BlockingQueue<Runnable> var6,
        ThreadFactory var7,
        RejectedExecutionHandler var8*/
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 6,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        // 2.给任务线程池处理
        Runnable target = new MyRunnable();
        // 三个线程任务
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        // 在队列中的线程任务
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);

        // 创建临时线程
        pool.execute(target);

    }
}

MyRunnable类：

package cn.edu.njust.threadpool;

public class MyRunnable implements Runnable{

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

运行结果：

在这里插入图片描述

由图中可以发现，程序未结束运行，说明线程池是不会关闭的；

关闭线程池：

方法说明
shutdown()等待线程任务结束后关闭线程（包括进入睡眠的线程）
shutdownNow()立即关闭线程池，不管线程任务进展如何

注意：实际开发中一般不会关闭线程池；

线程池处理Callable任务

Future<T>  submit(Callable<T> task)
    //执行任务，返回未来任务对象获取线程结果，一般拿来执行  Callable 任务

Executors工具类实现线程池

Executors得到线程池对象的常用方法：线程池的工具类通过调用方法返回不同类型的线程池对象。

方法名称说明
public static ExecutorService newCachedThreadPool() 线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了一段时间则会被回收掉。
public static ExecutorService newFixedThreadPool(int nThreads) 创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。
public static ExecutorService newSingleThreadExecutor () 创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。

Executors使用可能存在的陷阱：

在这里插入图片描述

定时器

简要：

  • 定时器是一种控制任务延时调用，或者周期调用的技术。
  • 作用：闹钟、定时邮件发送。

实现方式：

  • 方式一：Timer
  • 方式二： ScheduledExecutorService

Timer定时器

方法说明
public Timer()创建Timer定时器对象
public void schedule(TimerTask task, long delay, long period)开启一个定时器，按照计划处理TimerTask任务

Timer定时器的特点和存在的问题：

  • Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。
  • 可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行。

ScheduledExecutorService定时器

简要：ScheduledExecutorService是 jdk1.5中引入了并发包，目的是为了弥补Timer的缺陷, ScheduledExecutorService内部为线程池。

相关方法：

方法名说明
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)得到线程池对象
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)周期调度方法

ScheduledExecutorService的优点：基于线程池，某个任务的执行情况不会影响其他定时任务的执行。

生命周期、并发并行

并发与并行

简要：正在运行的程序（软件）就是一个独立的进程， 线程是属于进程的，多个线程其实是并发与并行同时进行的。

并发：

  • CPU同时处理线程的数量有限。
  • CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

并行：在同一个时刻上，同时有多个线程在被CPU处理并执行。

生命周期

线程的状态：

  • 线程的状态：也就是线程从生到死的过程，以及中间经历的各种状态及状态转换。
  • 理解线程的状态有利于提升并发编程的理解能力。

Java中的线程状态：

  • Java总共定义了6种状态
  • 6种状态都定义在Thread类的内部枚举类中。
public class Thread{
     ...
     public enum State {
     		NEW,
     		RUNNABLE,
     		BLOCKED,
     		WAITING,
     		TIMED_WAITING,
     		TERMINATED;}
     ...
}

6状态详细：

线程状态描述
NEW(新建)线程刚被创建，但是并未启动。
Runnable(可运行)线程已经调用了start()等待CPU调度
Blocked(锁阻塞)线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态；。
Waiting(无限等待)一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒
Timed Waiting(计时等待)同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

就是一个独立的进程， 线程是属于进程的，多个线程其实是并发与并行同时进行的。

并发：

  • CPU同时处理线程的数量有限。
  • CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

并行：在同一个时刻上，同时有多个线程在被CPU处理并执行。

生命周期

线程的状态：

  • 线程的状态：也就是线程从生到死的过程，以及中间经历的各种状态及状态转换。
  • 理解线程的状态有利于提升并发编程的理解能力。

Java中的线程状态：

  • Java总共定义了6种状态
  • 6种状态都定义在Thread类的内部枚举类中。
public class Thread{
     ...
     public enum State {
     		NEW,
     		RUNNABLE,
     		BLOCKED,
     		WAITING,
     		TIMED_WAITING,
     		TERMINATED;}
     ...
}

6状态详细：

线程状态描述
NEW(新建)线程刚被创建，但是并未启动。
Runnable(可运行)线程已经调用了start()等待CPU调度
Blocked(锁阻塞)线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态；。
Waiting(无限等待)一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒
Timed Waiting(计时等待)同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

快速链接

第1篇：Java基础部分–假期复习（关于String类的一些知识点）
第2篇：JavaSE_提高–static关键字、多态、部分常用API
第3篇：Java中的日期与时间、包装类、正则表示式简述、Arrays类、Lambda表达式的使用
第4篇：Java中的常用集合，包括List系列和Map系类、以及正则表达式的简单应用和红黑树原理
第5篇：JavaSE不可变集合、异常处理、Stream流
第6篇：Java中使用日志框架
第7篇：Java中的字符集和IO流
第8篇：Java中的线程

拜见老天師
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java线程
mood0916的博客
04-06 181
目录 1. 程序、进程、线程 为什么引入线程的目的？ 线程和进程之间的关系 2. 创建线程 1. 继承Thread类创建线程 2. 实现Runnable接口创建线程 3. 线程中常用方法 3. 线程状态 4. 线程的分类 5. 多线程的概念 5.1 Lock（锁） 5.2线程死锁 5.3线程通信 6. 新增创建线程方法 1. 程序、进程、线程 程序：为了完成某种功能，使用计算机编程语言完成任务的一组集合。（指一段静态代码） 进程：指正在执行任务的一组程序，即在计...
JAVA线程
互联网底层民工的博客
06-26 8970
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。
Java基础核心技术：多线程(day16-day17)
05-11
本套Java视频完全针对初级学员，课堂实录，自发布以来，好评如潮！Java视频中注重与学生互动，讲授幽默诙谐、细致入微，覆盖Java基础所有核心知识点，同类Java视频中也是代码量大、案例多、实战性强的。同时，本Java视频教程注重技术原理剖析，深入JDK源码，辅以代码实战贯穿始终，用实践驱动理论，并辅以必要的代码练习。
java 线程详解
muranfei的博客
07-02 1万+
一、线程的基本概念 一个线程就是在进程中的一个单一的顺序控制流. 而单个进程可以拥有多个并发执行的任务，每个任务都好像有自己的CPU一样，而其底层的机制就是切分CPU的时间，也就是CPU将轮流给每个任务分配其占用时间。 每个任务都觉得自己在一直占用CPU，而事实上是将CPU时间划分成片段分配给所有的任务。 在多个CPU的环境下，多线程的运作，可以极大的提供程序的运行速度，这就是线程存在的意...
Java线程系列详解
wang_yong_hui_1234的博客
04-15 3825
1）volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的，需要从主存中读取，synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。2）volatile仅能使用在变量级别，synchronized则可以使用在变量，方法。3）volatile仅能实现变量的修改可见性，而synchronized则可以保证变量的修改可见性和原子性。4）volatile不会造成线程的阻塞，而synchronized可能会造成线程的阻塞。
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6236
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
Java中线程思维导图
最新发布
05-31
Java中线程思维导图
代码分析Java中线程的等待与唤醒
08-26
Java 中线程的等待与唤醒机制详解 Java 中的线程等待和唤醒机制是多线程编程中一个重要的概念，它们之间的相互作用能够实现线程之间的协作和同步。下面将深入剖析 Java 中线程的等待和唤醒机制的原理和实现。 等待...
剖析Java中线程编程的概念
09-03
Java线程模型是其多线程特性的基础，它提供了一种机制，使得程序可以在执行过程中并行地执行多个任务。Java运行时系统完全支持线程，并且所有类库都考虑到了多线程环境，这使得Java成为编写并发程序的理想选择。线程...
java中线程的状态学习笔记
08-26
Java中的线程状态学习笔记 Java中的线程状态是指线程在其生命周期中所经历的一系列状态。在Java开发中，了解线程的状态是非常重要的，因为它可以帮助我们更好地理解线程的行为和生命周期。下面我们将详细介绍Java中...
java 中线程等待与通知的实现
08-29
Java 中线程等待与通知的实现 Java 中线程等待与通知是 Java 并发编程中非常重要的概念。线程等待与通知机制允许线程之间相互通信，实现了多线程之间的协作和同步。下面详细介绍 Java 中线程等待与通知的实现。 一...
编程必备：JAVA多线程详解
拾一二的博客
06-14 7798
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
JAVA多线程详解（超详细）
m0_74823434的博客
10-10 1万+
程序：开发写的代码称之为程序。程序就是一堆代码，一组数据和指令集，是一个静态的概念。进程(Process)：将程序运行起来，我们称之为进程。进程是执行程序的一次执行过程，它是动态的概念。进程存在生命周期，也就是说程序随着程序的终止而销毁。进程之间是通过TCP/IP端口实现交互的。线程(Thread)：线程是进程中的实际运作的单位，是进程的一条流水线，是程序的实际执行者，是最小的执行单位。通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程。线程是CPU调度和执行的最小单位。注意。
一篇搞懂Java多线程（全网最细）
让优秀成为一种习惯！
07-22 9035
Java多线程是一种强大而有趣的编程概念。它允许程序同时执行多个任务，就像一个宏大的交响乐团。每个线程都是一个独立的执行路径，有自己的速度和优先级。那么，我们期待多线程能给我们带来什么呢？
Java创建线程的七种方法，全网最全面总结~
CYK_byte的博客
02-03 2万+
属于基础的面试问题，一定要能够回答全哦~
Java基础学习——Java线程（一）多线程的发展史、线程的三种创建方式、线程的生命周期、线程的常用方法、线程的优先级
skx1102195517的博客
12-27 1198
一、什么是线程 1.概念 1）程序：为完成特定任务，用某种语言编写的一组指令的集合（程序是静态的） 2）进程：是程序的一次执行过程。进程作为分配资源的单位，在内存中为每个正在运行的进程分配不同的内存区域（进程是动态的），进程有生命周期。 3）线程： 一个进程同时执行多个线程，就是多线程。 2.单核CPU与多核CPU 对于在单核CPU上执行的多个线程，CPU按照时间片执行，一个时间片只能执行一个线程，但时间片时间特别短，造成了同时执行多个线程的假象。 多核CPU才真正实现了同一时间多个线程同时
java多线程（超详细）
热门推荐
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
java中 线程的生命周期
05-11
Java中线程的生命周期可分为五个状态：新建状态、就绪状态、运行状态、阻塞状态和终止状态。 1. 新建状态：新建线程对象后，线程处于新建状态，此时系统给线程分配内存空间，但尚未开始执行线程的run()方法。 2. 就绪状态：线程调用start()方法后进入就绪状态，此时线程已经准备好运行，并等待JVM的调度。 3. 运行状态：当线程获得CPU时间片并开始执行run()方法时，线程进入运行状态。 4. 阻塞状态：当线程调用sleep()、wait()、join()等方法时，线程进入阻塞状态，此时线程不会占用CPU时间片，只有等待特定的条件满足后才能继续执行。 5. 终止状态：线程执行完run()方法后，线程进入终止状态，此时线程占用的资源被释放，线程对象被销毁。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

拜见老天師

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值