多线程（Runnable 与 Callable）笔记

线程与进程

1、进程
进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间。
2、线程
线程是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程。
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。

线程调度

分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度
优先让优先级高的线程使用 CPU。如果线程的优先级相同，那么会随机选择一个(线程随机性)，

Java使用的为抢占式调度。
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使用率更高。

同步与异步

同步：排队执行 , 效率低但是安全。
异步：同时执行 , 效率高但是数据不安全。

并发与并行

并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

多线程的实现

1、想要实现多线程则必须继承Thread类（extends Thread），且在该类里面要重写 run()方法。
2、run方法就是线程要执行的任务方法，即：run方法里面的代码就是该线程要执行的任务（也就是新的执行路径执行的任务）。

3、run方法里面这条新的执行路径的触发方式 不是调用run方法。而是通过thread对象的start（）来启动任务。
eg:

public class Demo {
    public static void main(String[] args){
        MyThread m = new MyThread();
        m.start();//此时就开启了一个新的线程
    }
}

public class MyThread extends Thread {
    /**
     * run run方法就是线程要执行的任务方法
     */
     public void run() {
         //这里的代码 就是一条新的执行路径
         //这个执行路径的触发方式 不是调用run方法。而是通过thread对象的start（）来启动任务
         System.out.println("锄禾日当午，汗滴禾下土。");
   } 
}

Runnable 与 Callable接口

接口定义：

//Runnable接口
public interface Runnable {
public abstract void run();
}

//Callable接口
public interface Callable<V> {
V call() throws Exception;
}

Runnable使用步骤

public class Demo {
    public static void main(String[] args){
        //实现一个Runnable接口
        //1、创建一个任务对象
        MyRunnabde r = new MyRunnadle();
        //2、创建一个线程，并给它一个任务（为该线程分配一个任务）
        Thread t = new Thread(r);
        //3、执行这个线程
        t.start();
    }
}

public class MyRunnable implements Runnable{
    //重写（实现）它的抽象方法
    public void run() {
        //线程的任务
        System.out.println("床前明月光，疑是地上霜。");
    }
}

实现Runnable 与 继承Thread 相比有一下优势：
1、通过创建任务，然后给线程分配任务的方式来实现多线程。更适合多个线程同时执行相同任务的情况。
2、可以避免单继承所带来的局限性。
3、任务与线程本身是分离的，提高了程序的健壮性。
4、后续学习的线程池技术，接受Runnable类型的任务，不接收Thread类型的线程。

Callable使用步骤：

1、编写类实现Callable接口 , 实现call方法

//
class XXX implements Callable<T> {
    @Override
    public <T> call() throws Exception {
        return T;
    }
}

2、创建FutureTask对象 , 并传入第一步编写的Callable类对象

FutureTask<Integer> future = new FutureTask<>(callable);

3、通过Thread,启动线程

new Thread(future).start();

Runnable 与 Callable的相同点

都是接口。
都可以编写多线程程序。
都采用Thread.start()启动线程。

Runnable 与 Callable的不同点

Runnable没有返回值；Callable可以返回执行结果。
Callable接口的call()允许抛出异常；Runnable的run()不能抛出。

Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执
行，如果不调用不会阻塞。

线程池 Executors

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处

1、降低资源消耗。
2、提高响应速度。
3、提高线程的可管理性。

Java中的四种线程池 . ExecutorService

1、缓存线程池

/**
* 缓存线程池
* (长度无限制)
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在,则创建线程 并放入线程池, 然后使用
*/
ExecutorService service = Executors.newCachedThreadPool();
//向线程池中 加入 新的任务
service.execute(new Runnable() {

    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});
service.execute(new Runnable() {
    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});
service.execute(new Runnable() {
    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});

2、定长线程池

/**
* 定长线程池.
* (长度是指定的数值)
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*/
ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(new Runnable() {
@Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});
service.execute(new Runnable() {
    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});

3、单线程线程池

效果与定长线程池 创建时传入数值1 效果一致.
/**
* 单线程线程池.
* 执行流程:
* 1. 判断线程池 的那个线程 是否空闲
* 2. 空闲则使用
* 4. 不空闲,则等待 池中的单个线程空闲后 使用
*/
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new Runnable() {
    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});
service.execute(new Runnable() {
    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});

4、周期性任务定长线程池

public static void main(String[] args) {
/**
* 周期任务 定长线程池.
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*
* 周期性任务执行时:
* 定时执行, 当某个时机触发时, 自动执行某任务 .
* */
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
/**
* 定时执行
* 参数1. runnable类型的任务
* 参数2. 时长数字
* 参数3. 时长数字的单位
*/
/*service.schedule(new Runnable() {
@Override
public void run() {
System.out.println("俩人相视一笑~ 嘿嘿嘿");
}
},5,TimeUnit.SECONDS);
*/
/**
* 周期执行
* 参数1. runnable类型的任务
* 参数2. 时长数字(延迟执行的时长)
* 参数3. 周期时长(每次执行的间隔时间)
* 参数4. 时长数字的单位
*/
service.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        System.out.println("俩人相视一笑~ 嘿嘿嘿");
    }
},5,2,TimeUnit.SECONDS);
}