多线程的创建

方式一：继承Thread类

方式二：实现Runnable接口

方式三：JDK 5.0新增：实现Callable接口

Thread的常用方法

线程安全

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

线程安全问题案例模拟

线程同步

同步思想概述

方式一：同步代码块

方式二：同步方法

方式三：Lock锁

线程通信【了解】

线程池【重点】

线程池概述

线程池实现的API、参数说明

线程池处理Runnable任务

线程池处理Callable任务

Executors工具类实现线程池

补充知识：定时器

补充知识：并发、并行

补充知识：线程的生命周期

多线程的创建

什么是线程？
线程(thread)是一个程序内部的一条执行路径。
我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径。

程序中如果只有一条执行路径，那么这个程序就是单线程的程序。
多线程是什么？
多线程是指从软硬件上实现多条执行流程的技术。
多线程用在哪里，有什么好处
再例如：消息通信、淘宝、京东系统都离不开多线程技术。

方式一：继承Thread类

Thread类
Java是通过java.lang.Thread 类来代表线程的。 
按照面向对象的思想，Thread类应该提供了实现多线程的方式。
多线程的实现方案一：继承Thread类
    定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法
    创建MyThread类的对象
    调用线程对象的start()方法启动线程（启动后还是执行run方法的）
方式一优缺点：
    优点：编码简单
    缺点：线程类已经继承Thread，无法继承其他类，不利于扩展。


/**
 * 目标：多线程的创建方式一：继承Thread类实现。
 */
public class Test {
    public static void main(String[] args) throws Exception {
        //3、new一个新线程对象
        Thread t = new MyThread();

        //4、调用start方法启动线程（执行的还是run方法）
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出" + i);
        }
    }
}

/**
 * 1、定义一个线程类型继承Thread类
 */

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

1、为什么不直接调用了run方法，而是调用start启动线程。
    直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。
    只有调用start方法才是启动一个新的线程执行。
2、把主线程任务放在子线程之前了。
    这样主线程一直是先跑完的，相当于是一个单线程的效果了。
3、方式一是如何实现多线程的？
    继承Thread类
    重写run方法
    创建线程对象
    调用start()方法启动。
4、优缺点是什么？
    优点：编码简单
    缺点：存在单继承的局限性，线程类继承Thread后，不能继承其他类，不便于扩展。

方式二：实现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对象成为线程对象，并指定线程名称

/**
 * 目标：学会线程的创建方式二，理解它的优缺点。
 */
public class Test {
    public static void main(String[] args) throws Exception {

        //3、创建一个任务对象
        Runnable target = new MyRunnable();
        //4、把任务对象交给Thread处理
        Thread t = new Thread(target);
        //5、启动线程
        t.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出" + i);
        }
    }
}

/**
 * 1、定义一个线程任务类 实现Runnable接口
 */
class MyRunnable implements Runnable {
    /**
     * 2、重写run方法，定义线程的执行任务的
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

1、第二种方式是如何创建线程的？
    定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
    创建MyRunnable对象
    把MyRunnable任务对象交给Thread线程对象处理。
    调用线程对象的start()方法启动线程
2、第二种方式的优点
    优点：线程任务类只是实现了Runnale接口，可以继续继承和实现。
    缺点：如果线程有执行结果是不能直接返回的。

多线程的实现方案二：实现Runnable接口(匿名内部类形式)
    可以创建Runnable的匿名内部类对象。
    交给Thread处理。
    调用线程对象的start()启动线程。


public class Test {
    public static void main(String[] args) throws Exception {

        //创建一个任务对象
//        Runnable target = new Runnable() {
//            @Override
//            public void run() {
//                for (int i = 0; i < 5; i++) {
//                    System.out.println("子线程执行输出：" + i);
//                }
//            }
//        };

        Runnable target = () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("子线1程执行输出：" + i);
            }
        };

        //把任务对象交给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("子线2程执行输出：" + i);
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("子线3程执行输出：" + i);
            }
        }).start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出" + i);
        }
    }
}

方式三：JDK 5.0新增：实现Callable接口

1、前2种线程创建方式都存在一个问题：
    他们重写的run方法均不能直接返回结果。
    不适合需要返回线程执行结果的业务场景。

2、怎么解决这个问题呢？
    JDK 5.0提供了Callable和FutureTask来实现。
    这种方式的优点是：可以得到线程执行的结果。

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

FutureTask的API

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

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 目标：学会线程的创建方式三：实现Callable接口，结合FutureTask完成。
 */
public class Test {
    public static void main(String[] args) {
        //3、创建Callable任务对象
        Callable<String> callable1 = new MyCallable(100);

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

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

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

        try {
            // 如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。
            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;
    }

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

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

3种方式对比

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

Thread的常用方法

Thread常用API说明
    Thread常用方法：获取线程名称getName()、设置名称setName()、
    获取当前线程对象currentThread()。
    
    至于Thread类提供的诸如：yield、join、interrupt、不推荐的方法 stop 、
    守护线程、线程优先级等线程的控制方法，在开发中很少使用
1. 当有很多线程在执行的时候，我们怎么去区分这些线程呢？
    此时需要使用Thread的常用方法：getName()、setName()、currentThread()等。

Thread获取和设置线程名称

方法名称

说明

String getName()

获取当前线程的名称，默认线程名称是Thread-索引

void setName(String name)

将此线程的名称更改为指定的名称，通过构造器也可以设置线程名称

Thread类获得当前线程的对象

方法名称

说明

public static Thread currentThread()：

返回对当前正在执行的线程对象的引用

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

Thread的构造器

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

/**
 * 目标：线程的API
 */
public class Test {
    //main方法是由主线程负责调度的
    public static void main(String[] args) {
        //Thread t1 = new MyThread();
        Thread t1 = new MyThread("1号");//调用有参构造器
        //t1.setName("1号");
        t1.start();//启动线程
        System.out.println(t1.getName());

        //Thread t2 = new MyThread();
        Thread t2 = new MyThread("2号");
        //t2.setName("2号");
        t2.start();//启动线程
        System.out.println(t2.getName());

        //哪个线程执行它，它就得到哪个线程对象（当前线程对象）
        //主线程的名称就叫main
        Thread m = Thread.currentThread();
        System.out.println(m.getName());

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程输出" + i);
        }
    }
}

class MyThread extends Thread {

    public MyThread() {

    }

    public MyThread(String name) {
        // 为当前线程对象设置名称，送给父类的有参数构造器初始化名称
        super(name);
    }

    @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)	让当前线程休眠指定的时间后再继续执行，单位为毫秒。

/**
 * 目标：线程的API
 */
public class Test {
    //main方法是由主线程负责调度的
    public static void main(String[] args) throws Exception {
        for (int i = 0; i <= 5; i++) {
            System.out.println("输出：" + i);

            if (i == 3) {
                // 让当前线程进入休眠状态
                // 段子：项目经理让我加上这行代码，如果用户愿意交钱，我就注释掉。
                Thread.sleep(3000);//休眠3s
            }
        }
    }
}