java——线程

最新推荐文章于 2024-08-15 23:35:35 发布

Kristen Stewart

最新推荐文章于 2024-08-15 23:35:35 发布

阅读量593

点赞数

文章标签： java 开发语言 intellij-idea

本文链接：https://blog.csdn.net/weixin_46362658/article/details/123655918

版权

线程概述

什么是线程

线程是一个程序内部的一条执行路径
我们之前启动程序后，main方法的值其实就是一条单独的执行路径
程序中如果只有一条执行路径，那么这个程序就是单线程的程序

多线程是什么

多线程是指从软硬件上实现多条执行流程的技术
多线程用在哪里，有什么好处
如：通过是下载，或者下载的同时一起下载

多线程的创建

方式一：继承Thread类

java是通过java.lang.Thread类来代表线程的
按照面向对象的思想，Thread类应该提供了实现多种线程的方式
1. 定义一个子类MyThread继承线程java.lang.Thread,重写run（）方法
2. 创建MyThread类的对象
3. 调用线程对象的start(）方法启动线程（启动后还是执行run方法的）
  优缺点
- 优点：编码简单
- 缺点：线程已经继承Thread，无法继承其他类，不利于拓展
  为什么不直接调用run方法，而是调用start启动线程
- 直接调用run方法会当成普通方法执行，此时相当于还是单线程执行
- 只有调用start方法才是启动一共新的线程执行
  把主线程任务放在子线程之前
- 这样线程一直是先跑完，相当于是一个线程的效果了

/**
 * 目标：多线程的创建方式一：继承Thread类实现
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        //3.new一个新线程对象
        Thread t=new MyThread();
        //4.调用start方法启动线程（执行的还是run方法）
        t.start();//一定要先子线程再主线程
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出"+i);
        }

    }
}

/**
 * 定义一个线程Thread类
 */
class MyThread extends Thread{
    /**
     * 重写run方法，里面是定义线程以后要干啥
     */
    @Override
    public void run() {
        for (int i = 0; i <5 ; i++) {
            System.out.println("子线程执行输出"+i);
        }
    }
}

一定要先子线程再主线程

方式二：实现Runnable接口

定义一共线程任务MyRunnable实现Runnable接口，重写run（）方法
创建MyRunnable任务对象
把MyRunnable任务对象交给Thread处理
调用该线程对象的start（）方法启动线程

优点：线程任务类知识实现接口，可以继续继承和实现接口，扩张性强
缺点：编程多一层包装，如果线程有秩序结果是不可以直接放回的

package com.d1_create;

public class ThreadDemo2Other {
    public static void main(String[] args) {
        //3.创建一共任务对象
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("主线程执行输出" + i);
                }
            }
        };
        //4.把任务对象交给Thread处理
        Thread t=new Thread(target);
        t.start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程执行输出1 " + i);
                }
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                System.out.println("子线程执行输出2 " + i);
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                System.out.println("子线程执行输出3 " + i);
            }
        }).start();
    }
}

方式一：JDK5.0新增：实现Callable接口

利用Callable、FutureTask接口实现

一、得到任务对象
① 定义类实现Callable接口，重写call方法，封装要做的事情
② 用FutureTask把Callable对象封装成线程任务对象
二、把线程任务对象交给Thread处理
三、调用Thread的start方法启动线程，执行任务
四、线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果

/**
 * 目标：学会线程的创建方式三、实现Callable，结合FutureTask完成
 */
public class ThreadDemo3 {
    public static void main(String[] args) {

        //3创建Callable对象 交给FutureTask对象
        Callable<String> call=new MyCallable(100);
        //4.把Callable任务交给对象 交给Future 对象
        //FutureTask对象的作用1：是Runnable的对象（实现Runnable接口），可以交给Thread了
        //FutureTask对象的作用2：可以在线程执行完毕后通过其get方法得到线程执行完成的结果
        FutureTask<String> f1=new FutureTask<>(call);
        //5.交给线程处理
        Thread t1=new Thread(f1);
        //6.启动线程
        t1.start();

        Callable<String> call2=new MyCallable(100);
        FutureTask<String> f2=new FutureTask<>(call2);
        Thread t2=new Thread(f2);
        t2.start();

        try {
            //如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完猜提取结果。
            String rs1 = f1.get();
            System.out.println("第一个结果："+rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            String rs2 = f2.get();
            System.out.println("第一个结果："+rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
/**
 * 1.定义一共任务类，实现Callable接口，应该申明线程任务执行完毕后的结果数据类型
 */
class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n){
        this.n=n;
    }

    /**
     * 重写call方法（任务方法）
     * @return
     * @throws Exception
     */
    @Override
    public String call() throws Exception {
        int sum=0;
        for (int i = 0; i <= n ; i++) {
            sum+=i;
        }
        return "子线程执行的结果"+sum;
    }
}

优点：

线程任务类知识实现接口，可以继续继承类和实现接口，扩展性强
可以在线程执行完毕后去获取线程执行的结果

线程常用方法

在这里插入图片描述

package com.d1_create.d2_api;

public class ThreadDemo01 {
    //main方法是由主线负责调度的
    public static void main(String[] args) {
        Thread t1=new MyThread();
        //t1.setName("1号");
        t1.start();
        System.out.println(t1.getName());
        Thread t2=new MyThread();
        //t2.setName("2号");
        t2.start();
        System.out.println(t2.getName());

        //哪个线程执行它，他就得到哪个线程对象（当前线程对象）
        Thread m=Thread.currentThread();//main
        System.out.println(m.getName());
        for (int i = 0; i < 5; i++) {
            System.out.println("main程输出"+i);
        }
    }
}

package com.d1_create.d2_api;

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

Thread类的线程休眠方法

方法名称：public static void sleep(long time)但钱线程休眠后再继续执行，单位为毫秒

public class ThreadDemo02 {
    public static void main(String[] args) throws Exception {
        for (int i = 1; i <=5 ; i++) {
            System.out.println("输出"+i);
            if(i==3){
                //让当前线程进入休眠状态
                Thread.sleep(3000);
            }
        }
    }
}

在这里插入图片描述

线程安全问题

多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题

线程安全问题是什么、发生的原因

1.线程安全出现的原因

存在多线程并发
同时访问共享资源
存在修改共享资源
2.当有很多线程在执行的时候，我们怎么去区分这些线程呢？
此时需要使用Thread的常用方法：getName（），setName（），currentThread（）等

线程同步

如何才能保证线程安全？

让多个线程实现先后次序访问共享资源，这样就解决了安全问题

线程同步的核心思想

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

方法一：同步代码块

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

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

锁对象要求

理论上：锁对象只要对于当前同时执行的线程来说是同一个对象即可
规范上：建议使用共享资源作为锁对象
对于实例方法建议使用this作为锁对象
对于静态方法建议使用字节码（类名.class）对象作为锁对象
同步代码块是如何实现线程安全的
对出现的核心代码使用synchronized进行枷锁
每次只能一个进程占锁进入访问
同步代码块的同步锁对象有什么要求
对于实例方法建议使用this作为锁对象
对于静态方法建议使用字节码（类名.class）作为锁对象

synchronized (this) {
            // 2、判断余额是否足够
            if(this.money >= money){
                // 钱够了
                System.out.println(name+"来取钱，吐出：" + money);
                // 更新余额
                this.money -= money;
                System.out.println(name+"取钱后，余额剩余：" + this.money);
            }else{
                // 3、余额不足
                System.out.println(name+"来取钱，余额不足！");
            }
        }

方法二：同步方法

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

修饰符 synchronized 放回值类型 方法名称（形参列表）{
	操作共享资源代码
}

   /**
      小明 小红
     这个是核心代码，只需要加上synchronized就可以实现同步代码快
     */
    public synchronized void drawMoney(double money) {
        // 1、拿到是谁来取钱
        String name = Thread.currentThread().getName();
        // 同步代码块
        // 小明 小红
        // this == acc 共享账户
        synchronized (this) {
            // 2、判断余额是否足够
            if(this.money >= money){
                // 钱够了
                System.out.println(name+"来取钱，吐出：" + money);
                // 更新余额
                this.money -= money;
                System.out.println(name+"取钱后，余额剩余：" + this.money);
            }else{
                // 3、余额不足
                System.out.println(name+"来取钱，余额不足！");
            }
        }
    }

同步方法的底层原理

同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
如果方法是实例方法：同步方法默认用this作为锁的随想。但是代码要高度面向对象
如果方法是静态方法：同步方法默认用类名.class作为的锁的对象
1.是同步代码块好还是同步方法好一点
同步代码块锁范围更小，同步方法锁的范围更大

Lock锁

Lock实现提供比使用synchronized方法和语句可以获得更广泛锁定操作
Lock是皆苦不能直接实例化，这里采用他的实现类ReentrantLock来构建Lock锁对象

public void drawMoney(double money) {
        // 1、拿到是谁来取钱
        String name = Thread.currentThread().getName();
        // 同步代码块
        // 小明 小红
        lock.lock();//上锁，这样不依赖于面向对象的设计
        try {
            // 2、判断余额是否足够
            if(this.money >= money){
                // 钱够了
                System.out.println(name+"来取钱，吐出：" + money);
                // 更新余额
                this.money -= money;
                System.out.println(name+"取钱后，余额剩余：" + this.money);
            }else{
                // 3、余额不足
                System.out.println(name+"来取钱，余额不足！");
            }
        } finally {
            //这样可以防止上面代码遇到异常而不执行下面的解锁代码，这样就一致遇到死锁的问题
            lock.unlock();//解锁
        }
        
    }

线程通信

什么是线程通信、如何实现？

所谓线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。
线程通信常见形式
通过共享一个数据的方式实现。
根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。
线程通信实际应用场景
生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费生产者产生的数据。
要求：生产者线程生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己。

上述方法应该使用当前同步锁对象进行调用
Object类的等待和唤醒方法
在这里插入图片描述
上述方法的使用应当同步锁对象进行调用

package com.thread_communication;

public class Phone {
    //实现线程通信，默认认为手机当前处于等待来电提醒
    private boolean flag=false;
    public void run(){
        //a.负责来电提醒的线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        synchronized (Phone.this){
                            if (flag){
                                //代表要来电提醒了
                                System.out.println("您好，有新电话呼入，请接听");
                                flag=true;
                                Phone.this.notify();
                                Phone.this.wait();
                            }
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
        }).start();
        //b.接电话线程，正式接听了
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (Phone.this){
                    try {
                        //不断的接听电话
                        while (true){
                            if(flag){
                                //可以接听电话了
                                System.out.println("电话接听中");
                                Thread.sleep(5000);
                                flag=false;
                                //唤醒别人,等待自己
                                Phone.this.notify();
                                Phone.this.wait();
                            }else{
                                Phone.this.notify();
                                Phone.this.wait();
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        }).start();
    }
}

线程池（重点）

面试中的热点内容
线程池就是一个可以复用线程的技术
不使用线程池的问题
如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。
在这里插入图片描述
JDK 5.0起提供了代表线程池的接口：ExecutorService

方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象

在这里插入图片描述

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

在这里插入图片描述
临时线程什么时候创建啊？
新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
什么时候会开始拒绝任务？
核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。

线程池处理Runnable任务

ThreadPoolExecutor创建线程池对象示例

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

ExecutorService的常用方法

在这里插入图片描述

/**
    目标：自定义一个线程池对象，并测试其特性。
 */
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        // 1、创建线程池对象
        /**
         public ThreadPoolExecutor(int corePoolSize,
                                 int maximumPoolSize,
                                 long keepAliveTime,
                                 TimeUnit unit,
                                 BlockingQueue<Runnable> workQueue,
                                 ThreadFactory threadFactory,
                                 RejectedExecutionHandler handler)
         */
        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);//这样8个线程是不创建临时线程的，应为有3个线程被处理，有5个刚好在任务队列里，任务队列的容量刚好为5

        // 创建临时线程
        pool.execute(target);
        pool.execute(target);
        // 不创建，拒绝策略被触发！！！
        //pool.execute(target);

        // 关闭线程池（开发中一般不会使用）。
        // pool.shutdownNow(); // 立即关闭，即使任务没有完成，会丢失任务的！
        pool.shutdown(); // 会等待全部任务执行完毕之后再关闭（建议使用的）
    }
}

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出了：HelloWorld ==> "  + i);
        }
        try {
            System.out.println(Thread.currentThread().getName() + "本任务与线程绑定了，线程进入休眠了~~~");
            Thread.sleep(10000000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

线程池处理Callable任务

ExecutorService常用方法
在这里插入图片描述

/**
    1、定义一个任务类 实现Callable接口  应该申明线程任务执行完毕后的结果的数据类型
 */
public class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    /**
       2、重写call方法（任务方法）
     */
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n ; i++) {
            sum += i;
        }
        return Thread.currentThread().getName()
                + "执行 1-" + n+ "的和，结果是：" + sum;
    }
}

/**
目标：自定义一个线程池对象，并测试其特性。
/
public class ThreadPoolDemo2 {
public static void main(String[] args) throws Exception {
// 1、创建线程池对象
/*
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
*/
ExecutorService pool = new ThreadPoolExecutor(3, 5 ,
6, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5) , Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy() );

    // 2、给任务线程池处理。
    Future<String> f1 = pool.submit(new MyCallable(100));
    Future<String> f2 = pool.submit(new MyCallable(200));
    Future<String> f3 = pool.submit(new MyCallable(300));
    Future<String> f4 = pool.submit(new MyCallable(400));
    Future<String> f5 = pool.submit(new MyCallable(500));

// String rs = f1.get();
// System.out.println(rs);

    System.out.println(f1.get());
    System.out.println(f2.get());
    System.out.println(f3.get());
    System.out.println(f4.get());
    System.out.println(f5.get());
}

}

方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象

Executors：线程池的工具类通过调用方法返回不同类型的线程池对象
在这里插入图片描述
注意：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的。

import java.util.concurrent.*;

/**
    目标：使用Executors的工具方法直接得到一个线程池对象。
 */
public class ThreadPoolDemo3 {
    public static void main(String[] args) throws Exception {
        // 1、创建固定线程数据的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);//没有零时工

        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable()); // 已经没有多余线程了
    }
}

Executors使用可能存在的陷阱
大型并发系统环境中使用Executors如果不注意可能会出现系统风险。
这样任务不受控制在这里插入图片描述
Executors工具类底层是基于什么方式实现的线程池对象？
线程池ExecutorService的实现类：ThreadPoolExecutor

Executors是否适合做大型互联网场景的线程池方案？
不合适。
建议使用ThreadPoolExecutor来指定线程池参数，这样可以明确线程池的运行规则，规避资源耗尽的风险。

定时器

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

实现定时器的方式
方式一：Timer
方式二： ScheduledExecutorService
在这里插入图片描述
Timer定时器的特点和存在的问题
1、Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。
2、可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行。
ScheduledExecutorService定时器
ScheduledExecutorService是 jdk1.5中引入了并发包，目的是为了弥补Timer的缺陷, ScheduledExecutorService内部为线程池。
在这里插入图片描述

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

/**
    目标：Timer定时器的使用和了解。
 */
public class TimerDemo2 {
    public static void main(String[] args) {
        // 1、创建ScheduledExecutorService线程池，做定时器
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);

        // 2、开启定时任务
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：AAA  ==》 " + new Date());
                try {
                    Thread.sleep(100000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, 0, 2, TimeUnit.SECONDS);


        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：BBB  ==》 " + new Date());
                System.out.println(10 / 0);
            }
        }, 0, 2, TimeUnit.SECONDS);


        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：CCC  ==》 " + new Date());
            }
        }, 0, 2, TimeUnit.SECONDS);

    }
}

并发、并行

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

CPU同时处理线程的数量有限。
CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。
对并行的理解
在同一个时刻上，同时有多个线程在被CPU处理并执行。
简单说说并发和并行的含义
并发：CPU分时轮询的执行线程。
并行：同一个时刻同时在执行。
Java的线程状态
Java总共定义了6种状态
6种状态都定义在Thread类的内部枚举类中。