线程、线程常用方法、线程安全问题、线程同步、线程通信（了解）、线程池、定时器、并发与并行、线程的状态

线程

线程概述

• 线程(thread)是一个程序内部的一条执行路径
• 我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径
• 程序中如果只有一条执行路径，那么这个程序就是单线程的程序
• 多线程是指从软硬件上实现多条执行流程的技术

多线程的适用场景案例

• 消息通信、淘宝、京东系统都离不开多线程技术

多线程的实现方案

方案一:继承Thread类

步骤

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

代码展示 ①

class MyThreed extends Thread{
    @Override
    public void run() {
        //输入想执行的进程
    }
}

②③

public static void main(String[] args) {
    MyThreed mt=new MyThreed();
    //调用线程对象的start()方法启动线程(启动后还是执行run方法的)
    mt.start();       
 }

优缺点:

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

问题

为什么不直接调用了run方法，而是调用start方法启动线程？

• 直接调用run方法会当成普通方法执行，此时相当于还是单线程执行
• 只有调用start方法才是启动一个新的线程执行

如果我们把主线程任务放在子线程之前了，会出现什么情况呢？

• 这样主线程一直是先跑完的，相当于是一个单线程的效果了

方案二:实现Runnable接口

步骤

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

写代码之前我们先看一下Thread类的构造器

代码展示 ①

class MyRunnable implements Runnable{
    @Override
    public void run() {
        //输入想执行的进程
    }
}

②③④

Runnable mr=new MyRunnable();
 Thread t=new Thread(mr);
 t.start();

优缺点

• 优点: 线程任务类只是实现了Runnale接口，可以继续继承和实现
• 缺点:如果线程有执行结果是不能直接返回的

方案二:实现Runnable接口(匿名内部类形式)

步骤

• ①可以创建Runnable的匿名内部类对象
• ②交给Thread处理
• ③调用线程对象的start()启动线程

代码展示

public static void main(String[] args) {
        Runnable mr=new Runnable() {
            @Override
            public void run() {
               //输入想执行的进程
            }
        };
        Thread t=new Thread(mr);
        t.start();
    }

方案三:利用Callable接口和FutureTask类实现

步骤

• ①得到任务对象 1.定义类实现Callable接口，重写call方法，封装要做的事情 2.用FutureTask把Callable对象封装成线程任务对象(FutuerTask实现了Runnable接口)
• ②把线程任务对象交给Thread处理
• ③调用Thread的start方法启动线程，执行任务
• ④线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果

FutureTask的API

代码展示 ①

//此处泛型中的数据类型与
                                  //返回值的数据类型一致   
class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
       //输入想执行的进程
        return "返回你想要的结果";
    }
}

②③④

Callable<String> mc=new MyCallable();
 //用FutureTask把Callable对象封装成线程任务对象
 FutureTask<String> ft=new FutureTask<>(mc);
 //把线程任务对象交给Thread处理
 Thread t=new Thread(ft);
 //通过FutureTask的get方法去获取任务执行的结果
 System.out.println(ft.get());

优缺点:

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

三种方案特点对比

线程常用方法

Thread常用API说明

• Thread常用方法: 获取线程名称getName()、设置名称setName()、获取当前线程对象currentThread()
• 至于其他的，能力有限，暂不说明

Thread类获得当前线程的对象

注意

• 此方法是Thread类的静态方法，可以直接使用Thread类调用
• 这个方法是在哪个线程执行中调用的，就会得到哪个线程对象

Thread的构造器

Thread类的线程休眠方法

其他常用方法

部分代码展示

//为当前线程指定名称
   Thread t=new Thread();
   t.setName("小V");
   Thread.currentThread().setName("小V");
   //得到当前线程的名称
   System.out.println(t.getName());
   System.out.println(Thread.currentThread().getName());
   //让当前线程休眠5000毫秒（5秒）
   Thread.sleep(5000);

线程安全问题

线程安全问题

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

举个例子，小明和小红公用一个账户，账户里只有10000元，有一天他们同时去取钱，同时取10000元，这样趁机器没反应过来，就都取了10000元，导致账户变成了-10000元

代码演示 首先定义一个账户类，余额初始化为10000，在写一个取钱方法

public class Account {
    private double money=10000;

    public double getMoney() {
        return money;
    }

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

    public void drawMoney(double money) {
        if (money<=this.money){
            System.out.println(Thread.currentThread().getName()+"取出"+money+"元");
            this.money-=money;
            System.out.println("余额还剩"+this.money+"元");
        }else {
            System.out.println("余额不足");
        }
    }
}

再写一个与取钱有关的线程类

public class DrawThread extends Thread{
    private static Account a;
    public DrawThread(Account a,String name){
       //调用父类构造器，为线程命名
        super(name);
        this.a=a;
    }

    @Override
    public void run() {
        a.drawMoney(10000);
    }
}

最后，创建两个线程并共用一个账户

public static void main(String[] args) throws Exception{
  Account a=new Account();
  new DrawThread(a,"小红").start();
  new DrawThread(a,"小明").start();
 }

就会出现以下情况：都能取，账户余额变负数了

小明取出10000.0元
小红取出10000.0元
余额还剩0.0元
余额还剩-10000.0元

这整个模型是这样的：

小总结

线程安全问题出现的原因：

• 存在多线程并发
• 同时访问共享资源
• 存在修改共享资源

线程同步

目的：为了解决线程安全问题

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

核心思想

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

加锁方式一：同步代码块

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

格式

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

我们把上面账户类中与线程有关的代码进行上锁，如下

public void drawMoney(double money) {
    synchronized (this) {  //此处this代表着该账户，该账户是小明和小红所共享的
        if (money<=this.money){
            System.out.println(Thread.currentThread().getName()+"取出"+money+"元");
            this.money-=money;
            System.out.println("余额还剩"+this.money+"元");
        }else {
            System.out.println("余额不足");
        }
    }
}

这样问题便已解决

锁对象要求

• 理论上:锁对象只要对于当前同时执行的线程来说是同一个对象即可

问题

锁对象用任意唯一的对象好不好呢?

• 不好，会影响其他无关线程的执行

锁对象的规范要求：

• 规范上: 建议使用共享资源作为锁对象
• 对于实例方法建议使用this作为锁对象
• 对于静态方法建议使用字节码 (类名.class) 对象作为锁对象

加锁方式二：同步方法

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

格式

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

我们把上面账户类中与线程有关的方法进行上锁，如下

public synchronized void drawMoney(double money) {
            if (money<=this.money){
                System.out.println(Thread.currentThread().getName()+"取出"+money+"元");
                this.money-=money;
                System.out.println("余额还剩"+this.money+"元");
            }else {
                System.out.println("余额不足");
        }
    }

同步方法底层原理

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

问题

是同步代码块好还是同步方法好一点?

• 同步代码块锁的范围更小，同步方法锁的范围更大

加锁方式三：Lock锁

• 为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便
• Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
• Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象（该锁是可以跨方法的，即可以在一个方法中实现关锁，一个方法中实现开锁）

Lock的API

我们把上面账户类中与线程有关的方法进行上锁，如下

////final修饰后: 锁对象是唯一和不可替换，非常专业
public final Lock rl=new ReentrantLock();
    public  void drawMoney(double money) {
        rl.lock();
            if (money<=this.money){
                System.out.println(Thread.currentThread().getName()+"取出"+money+"元");
                this.money-=money;
                System.out.println("余额还剩"+this.money+"元");
            }else {
                System.out.println("余额不足");
        }
            rl.unlock();
    }

线程通信（了解）

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

• 所谓线程通信就是线程间相互发送数据，线程通信通常通过共享一个数据的方式实现
• 线程间会根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做

线程通信常见模型

• 生产者与消费者模型:生产者线程负责生产数据，消费者线程负责消费数据
• 要求:生产者线程生产完数据后，唤醒消费者，然后等待自己;消费者消费完该数据后，唤醒生产者，然后等待自己

线程通信案例模拟

• 假如有这样一个场景，小明和小红有三个爸爸，爸爸们负责存钱，小明和小红负责取钱，必须一存、一取（存多少，取多少）(不恰当但好理解)

模型

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

Object类的等待和唤醒方法:

注意

• 上述方法应该使用当前同步锁对象进行调用

代码展示

我们要把账户类给写出来，余额初始化为0，并写出与取钱存钱相关的功能，要记得上锁，记得要先唤醒再释放

public class Account {
    private double money=0;

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
    public synchronized void drawMoney(double money) throws Exception{
            if (money<=this.money){
                System.out.println(Thread.currentThread().getName()+"来取钱了,取了"+money+"元");
                this.money-=money;
                this.notifyAll();
                this.wait();
            }else {
                this.notifyAll();
                this.wait();
        }
    }

    public synchronized void saveMonry(double money) throws Exception {
        if (this.money==0){
            System.out.println(Thread.currentThread().getName()+"存了"+money+"元");
            this.money+=money;
            this.notifyAll();
            this.wait();
        }else {
            this.notifyAll();
            this.wait();
        }
    }
}

然后，把存钱和取钱的线程类写出来

存钱

public class SaveMoney extends Thread{
    private static Account a;
    public SaveMoney(Account a, String name){
        super(name);
        this.a=a;
    }

    @Override
    public void run() {
        while (true) {
            try {
                a.saveMonry(10000);
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

取钱

public class DrawThread extends Thread{
    private static Account a;
    public DrawThread(Account a,String name){
        super(name);
        this.a=a;
    }

    @Override
    public void run() {
        while (true) {
            try {
                a.drawMoney(10000);
                Thread.sleep(2000);
            } catch (Exception e) {
               e.printStackTrace();
            }
        }
    }
}

最后创建线程执行就行了

public static void main(String[] args) throws Exception{
        Account a=new Account();
       new DrawThread(a,"小红").start();
       new DrawThread(a,"小明").start();
       new SaveMoney(a,"干爹").start();
       new SaveMoney(a,"亲爹").start();
       new SaveMoney(a,"岳父").start();
    }

线程池

线程池就是一个可以复用线程的技术

不使用线程池的问题

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

线程池工作原理模型

如何得到线程池对象

方式一:

• JDK 5.0起提供了代表线程池的接口: ExecutorService(ExecutorService代表线程池)
• 使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象

方式二:

• 使用Executors(线程池的工具类) 调用方法返回不同特点的线程池对象

得到线程池对象方式一

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

ThreadPoolExecutor构造器的参数说明

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

• 参数一: 指定线程池的线程数量 (核心线程): corePoolsize——>不能小于0
• 参数二:指定线程池可支持的最大线数: maximumPoolsize——>最大数量>=核心线程数量
• 参数三:指定临时线程的最大存活时间:keepAliveTime——>不能小于0
• 参数四:指定存活时间的单位(秒、分、时、天): unit——>时间单位
• 参数五: 指定任务队列: workQueue——>不能为null
• 参数六:指定用哪个线程工厂创建线程: threadFactory——>不能为null
• 参数七: 指定线程忙，任务满的时候，新任务来了怎么办: handler——>不能为null

线程池常见面试题

临时线程什么时候创建啊?

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

什么时候会开始拒绝任务?

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

ExecutorService的常用方法

TimeUnit类表示的时间单位

新任务拒绝策略

以Runnable类线程为例，代码展示

//以KTV为例，好理解
 ExecutorService e=new ThreadPoolExecutor(3,5,2,
                TimeUnit.MINUTES, new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        //核心线程的数量（3个原始员工）
        e.execute(new MyThread());
        e.execute(new MyThread());
        e.execute(new MyThread());
        //指定任务队列（KTV外等候区，最多等待5个）
        e.execute(new MyThread());
        e.execute(new MyThread());
        e.execute(new MyThread());
        e.execute(new MyThread());
        e.execute(new MyThread());
        //开始生成新的线程（当等候区已满，3个原始员工忙不过来，临时招收临时工）
        e.execute(new MyThread());
        e.execute(new MyThread());
        //过载，处理，拒绝（不在接纳顾客）
        e.execute(new MyThread());
        e.shutdown();

线程池处理Runnable任务

• 使用ExecutorService的方法:void execute(Runnable target)

线程池如何处理Callable任务，并得到任务执行完后返回的结果

• 使用ExecutorService的方法:Future command）
• FutureTask类是Future接口的实现类

处理Callable任务代码展示

public static void main(String[] args) throws Exception{
        ExecutorService e=new ThreadPoolExecutor(3,5,2,
                TimeUnit.MINUTES, new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
       Future f= e.submit(new MyCallable());
       Future f1= e.submit(new MyCallable());
       Future f2= e.submit(new MyCallable());
        System.out.println(f.get());
        System.out.println(f1.get());
        System.out.println(f2.get());
        e.shutdown();
    }
}
class MyCallable implements Callable<String>{

    @Override
    public String call() throws Exception {
        return Thread.currentThread().getName()+"我爱你";
    }
}

得到线程池对象方式二

Executors工具类得到线程池对象

Executors得到线程池对象的常用方法

• Executors:线程池的工具类通过调用方法返回不同类型的线程池对象

注意：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的

这些方法直接用Executors工具类调用，然后用一个线程池对象去接就行，示例如下

ExecutorService pool=Executors.newCachedThreadPool();

功能正常调用就行

Executors使用可能存在的陷阱

• 大型并发系统环境中使用Executors如果不注意可能会出现系统风险

规范

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

定时器

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

定时器的实现方式

• 方式一: Timer
• 方式二: ScheduledExecutorService

Timer定时器

如果我想延迟2秒执行，代码，并且改代码每3秒执行一次 代码如下

public static void main(String[] args) {
        Timer t=new Timer();
        t.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("你好");
            }
        },2000,3000);
    }

参数二：延迟代码运行时间，单位：毫秒参数三：运行代码每隔多长时间再运行一次，单位：毫秒

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

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

就是如果我们用一个Timer对象开启了多个定时器，而其中一个定时器进行了休眠，这样导致休眠定时器后面的定时器的执行产生了时间误差（如果又新建了个定时器对象，就可以没这个问题了，但一直新建Timer类对象总归是不好的）

ScheduledExecutorService定时器

ScheduledExecutorService是idk1.5中引入了并发包，目的是为了弥补Timer的缺陷, ScheduledExeutorService内部为线程池

ScheduledExecutorService的优点

• 基于线程池，某个任务的执行情况不会影响其他定时任务的执行

代码展示

ScheduledExecutorService ese=Executors.newScheduledThreadPool(3);
        ese.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(new Date());
            }
        },2,3, TimeUnit.SECONDS);

参数二：延迟代码运行时间，单位：毫秒
参数三：运行代码每隔多长时间再运行一次，单位：毫秒
参数四：时间单位

并发与并行

正在运行的程序(软件)就是一个独立的进程，线程是属于进程的，多个线程其实是并发与并行同时进行的

并发

• CPU同时处理线程的数量有限
• CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发 （比如说闪电侠，它一瞬间干趴了很多人，在别人眼中这些被干的人是同时倒下的，但其实是闪电侠的速度很快，给人感觉是同时打了很多人，这就是并发）

并行

• 在同一个时刻上，同时有多个线程在被CPU处理并执行 （这个好理解，比如说复仇者联盟打怪，他们每一个人就相当于一个线程，他们都在打怪，这就叫并行）

线程的状态

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

Java线程的状态

• Java总共定义了6种状态
• 6种状态都定义在Thread类的内部枚举类中

六种如下

public class Thread{ 
         ...
 public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }
        ...
}

线程的6种状态互相转换