Java多线程

多线程

一、多线程的创建

1、继承Thread类

（1）步骤：

①定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法

②创建MyThread类的对象

③调用线程对象的start()方法启动线程（启动后还是执行run方法的）

public class TestThread {
    public static void main(String[] args){
        MyThread myThread = new MyThread();
        myThread.start();
        for(int i=0;i<5;i++){
            System.out.println("主线程输出:"+i);
        }

    }
}

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

（2）优缺点：

• 优点：编码简单

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

（3）问题解答

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

直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。

只有调用start方法才是启动一个新的线程执行。

2、把主线程任务放在子线程之前了。

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

2、实现Runnable接口

（1）步骤

①定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法

②创建MyRunnable任务对象

③把MyRunnable任务对象交给Thread处理。

④调用线程对象的start()方法启动线程

Thread构造器：

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

public class ThreadDemo2 {
    public static void main(String[] args) {
        MyRunable myRunable = new MyRunable();
        Thread thread = new Thread(myRunable);
        thread.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程输出:" + i);
        }
    }
}

class MyRunable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程输出:" + i);
        }
    }
}

（2）优缺点

• 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。

• 缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

（3）匿名内部类方式

public class ThreadDemo3 {
    public static void main(String[] args){
        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();
    }
}

3、利用Callable、FutureTask接口实现。

（1）步骤

①、得到任务对象

1.定义类实现Callable接口，重写call方法，封装要做的事情。

2.用FutureTask把Callable对象封装成线程任务对象。

②、把线程任务对象交给Thread处理。

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

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

FutureTask API

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

public class ThreadDemo4 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallAble myCallAble = new MyCallAble(100);
        FutureTask<String> stringFutureTask = new FutureTask<>(myCallAble);
        new Thread(stringFutureTask).start();
        String s = stringFutureTask.get();
        System.out.println(s);
    }
}

class MyCallAble implements Callable<String>{

    private int num;

    public MyCallAble(int num){
        this.num=num;
    }

    @Override
    public String call() throws Exception {
        int sum=0;
        for (int i=1;i<=num;i++){
            sum+=i;
        }

        return  "1到"+num+"的累计和为"+sum;
    }
}

（2）优缺点

• 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。

l可以在线程执行完毕后去获取线程执行的结果。

• 缺点：编码复杂一点。

4、Thread常用API说明

Thread常用方法：获取线程名称getName()、设置名称setName()、获取当前线程对象currentThread()。

至于Thread类提供的诸如：yield、join、interrupt、不推荐的方法 stop 、守护线程、线程优先级等线程的控制方法，在开发中很少使用，这些方法会在高级篇以及后续需要用到的时候再为大家讲解。

1. 当有很多线程在执行的时候，我们怎么去区分这些线程呢？

此时需要使用Thread的常用方法：getName()、setName、currentThread()等。

Thread构造方法

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

Thread常用方法

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

二、线程安全同步

1、同步代码块

格式：

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

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

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

public void drawMoney(int money) {
        String name = Thread.currentThread().getName();
        synchronized (this) {
            if (this.money >= money) {
                System.out.println(name + "取钱成功,吐出" + money);
                this.money -= money;
                System.out.println("取钱后剩余" + this.money);
            } else {
                System.out.println(name+"穷逼，去给我挣钱去");
            }
        }
    }

（1）锁对象要求

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

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

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

锁对象的规范要求

• 规范上：建议使用共享资源作为锁对象。

• 对于实例方法建议使用this作为锁对象。

• 对于静态方法建议使用字节码（类名.class）对象作为锁对象。

2、同步方法

作用：把出现线程安全问题的核心方法给上锁。

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

格式：

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

    public synchronized void drawMoney(int money) {
        String name = Thread.currentThread().getName();
        if (this.money >= money) {
            System.out.println(name + "取钱成功,吐出" + money);
            this.money -= money;
            System.out.println("取钱后剩余" + this.money);
        } else {
            System.out.println(name + "穷逼，去给我挣钱去");
        }
    }

（1）同步方法底层原理：

• 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。

• 如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！

• 如果方法是静态方法：同步方法默认用类名.class作为的锁对象

3、Lock锁

• 为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便。

• Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。

• Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象。

方法名称	说明
public ReentrantLock()	获得Lock锁的实现类对象

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

private final Lock lock = new ReentrantLock();



    public void drawMoney(int money) {
        String name = Thread.currentThread().getName();

        lock.lock();//加锁
        try {
            if (this.money >= money) {
                System.out.println(name + "取钱成功,吐出" + money);
                this.money -= money;
                System.out.println("取钱后剩余" + this.money);
            } else {
                System.out.println(name + "穷逼，去给我挣钱去");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//释放锁
        }
    }

三、线程通信

Object类等待和唤醒方法

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

注意

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

模拟客户系统:

ACount账户类

package threadstudy.communication;

/**
 * 账户类
 */
public class ACount {

    /**
     * 账户id
     */
    private String id;

    /**
     * 余额
     */
    private Integer money;

    public ACount() {

    }

    public ACount(String id, Integer money) {
        this.id = id;
        this.money = money;
    }

    /**
     * 取钱方法
     *
     * @param money
     */
    public synchronized void drawMoney(Integer money) {
        String name = Thread.currentThread().getName();
        try {
            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 deposit(int money) {
        String name = Thread.currentThread().getName();
        try {
            if (this.money < money) {
                //没钱
                this.money+=money;
                System.out.println(name + "存钱成功，余额" + this.money);
                this.notifyAll();
                this.wait();
            } else {
                //还有钱，不存
                this.notifyAll();
                this.wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Integer getMoney() {
        return money;
    }

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


}

DrawThread 取钱线程类

package threadstudy.communication;

/**
 * 取钱线程类
 */
public class DrawThread extends Thread{

    /**
     * 账户
     */
    private ACount aCount;

    public DrawThread(ACount aCount,String name){
        super(name);
        this.aCount=aCount;
    }

    @Override
    public void run() {
        try {
            while (true){
                aCount.drawMoney(10000);
                Thread.sleep(3000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

DepositThread存钱线程类

package threadstudy.communication;

/**
 * 存钱线程类
 */
public class DepositThread extends Thread{

    /**
     * 账户
     */
    private ACount aCount;

    public DepositThread(ACount aCount,String name){
        super(name);
        this.aCount=aCount;
    }

    @Override
    public void run() {
        try {
            while (true){
                aCount.deposit(10000);
                Thread.sleep(2000);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

main

package threadstudy.communication;

public class DoMain {
    public static void main(String[] args) {
        //新建一个账户，默认没有钱
        ACount aCount = new ACount("ICBC", 0);

        //两个消费者
        new DrawThread(aCount,"小明").start();
        new DrawThread(aCount,"小红").start();

        //三个生产者
        new DepositThread(aCount,"亲爸").start();
        new DepositThread(aCount,"干爸").start();
        new DepositThread(aCount,"岳父").start();

    }
}

四、线程池

谁代表线程池

lJDK 5.0起提供了代表线程池的接口：ExecutorService

如何得到线程池对象

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

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

1、方式一

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的常用方法

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

新任务拒绝策略

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

public class TestThreadPool {
    public static void main(String[] args) {
        /**
         * public ThreadPoolExecutor(int corePoolSize,
         *                               int maximumPoolSize,
         *                               long keepAliveTime,
         *                               TimeUnit unit,
         *                               BlockingQueue<Runnable> workQueue,
         *                               ThreadFactory threadFactory,
         *                               RejectedExecutionHandler handler)
         */
        ExecutorService threadPool = new ThreadPoolExecutor(3,
                5,
                3,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

        Thread thread = new Thread(() -> {
            for (int i = 1; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+"子线程输出" + i);
            }
            try {

                System.out.println(Thread.currentThread().getName()+"线程进入休眠");
                Thread.sleep(100000000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        //三个核心线程跑
        threadPool.execute(thread);
        threadPool.execute(thread);
        threadPool.execute(thread);
        //进入队列
        threadPool.execute(thread);
        threadPool.execute(thread);
        threadPool.execute(thread);
        threadPool.execute(thread);
        threadPool.execute(thread);
        //队列满，剩余2个临时线程跑
        threadPool.execute(thread);
        threadPool.execute(thread);
        //拒绝
        threadPool.execute(thread);

        threadPool.shutdownNow();//立刻关闭，不管线程有无结束
        threadPool.shutdown();//等线程执行完毕在结束
    }
}

public class ThreadPool2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /**
         * public ThreadPoolExecutor(int corePoolSize,
         *                               int maximumPoolSize,
         *                               long keepAliveTime,
         *                               TimeUnit unit,
         *                               BlockingQueue<Runnable> workQueue,
         *                               ThreadFactory threadFactory,
         *                               RejectedExecutionHandler handler)
         */
        ExecutorService threadPool = new ThreadPoolExecutor(3,
                5,
                5,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
                );

        Future<String> future1 = threadPool.submit(new TestCallAble(100));
        Future<String> future2 = threadPool.submit(new TestCallAble(200));
        Future<String> future3 = threadPool.submit(new TestCallAble(300));
        Future<String> future4 = threadPool.submit(new TestCallAble(400));

        System.out.println(future1.get());
        System.out.println(future2.get());
        System.out.println(future3.get());
        System.out.println(future4.get());

        threadPool.shutdown();
    }

临时线程什么时候创建？

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

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

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

2、方式二

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

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

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

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

Executors使用可能存在的陷阱

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

方法名称	存在问题
public static ExecutorService newFixedThreadPool(int nThreads)	允许请求的任务队列长度是Integer.MAX_VALUE，可能出现OOM错误（ java.lang.OutOfMemoryError ）
public static ExecutorService newSingleThreadExecutor()
public static ExecutorService newCachedThreadPool()	创建的线程数量最大上限是Integer.MAX_VALUE， 线程数可能会随着任务1:1增长，也可能出现OOM错误（ java.lang.OutOfMemoryError ）
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

public class ThreadPool3 {
    public static void main(String[] args) {
        //使用Executors工具类创建线程池对象，
        /**
         * public static ExecutorService newFixedThreadPool(int nThreads) {
         *         return new ThreadPoolExecutor(nThreads, nThreads,
         *                                       0L, TimeUnit.MILLISECONDS,
         *                                       new LinkedBlockingQueue<Runnable>());
         *     }
         */
        ExecutorService threadPool = Executors.newFixedThreadPool(3);
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + "线程输出" + i);
            }
        });

        threadPool.execute(thread);
        threadPool.execute(thread);
        threadPool.execute(thread);
    }
}

五、定时器

定时器

• 定时器是一种控制任务延时调用，或者周期调用的技术。

• 作用：闹钟、定时邮件发送。

定时器的实现方式

• 方式一：Timer

• 方式二： ScheduledExecutorService

1、Timer定时器

构造器	说明
public Timer()	创建Timer定时器对象

方法	说明
public void schedule([TimerTask](file:///D:/course/%E5%9F%BA%E7%A1%80%E9%98%B6%E6%AE%B5/API%E6%96%87%E6%A1%A3/docs/api/java.base/java/util/TimerTask.html) task, long delay, long period)	开启一个定时器，按照计划处理TimerTask任务

public class TimerDemo1 {
    public static void main(String[] args) {
        //创建一个定时器
        Timer timer = new Timer(); //定时器本身就是一个单线程


        //调用方法，处理定时任务
        /**
         * public void schedule(TimerTask task, long delay, long period)
         */
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了...");
            }
        },0,2000);

        //出现异常，直接退出 影响其他线程
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(10/0);
            }
        },0,2000);
    }
}

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

1、Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。

2、可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行。

2、ScheduledExecutorService

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

Executors的方法	说明
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)	得到线程池对象

ScheduledExecutorService的方法	说明
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)	周期调度方法

public class ScheduleExecuteServerDemo {
    public static void main(String[] args) {
        //创建ScheduledExecutorService线程池，做定时器
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);

        //开启定时任务
        scheduledThreadPool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"定时器");
            }
        },0,2, TimeUnit.SECONDS);

        //出现异常，直接消掉，不影响其他定时器任务，
        scheduledThreadPool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(10/0);
            }
        },0,2,TimeUnit.SECONDS);


    }
}

ScheduledExecutorService的优点

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

六、并行与并发

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

并发的理解：

• CPU同时处理线程的数量有限。

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

并行的理解：

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

六、线程的生命周期

线程的状态

• 线程的状态：也就是线程从生到死的过程，以及中间经历的各种状态及状态转换。

• 理解线程的状态有利于提升并发编程的理解能力。

Java线程的状态:

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

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

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