Java多线程

多线程技术概述

线程与进程

进程

是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程

是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少

有一个线程
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分

成若干个线程

线程调度

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，

Java使用的为抢占式调度。
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，

只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时

刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使

用率更高。

同步与异步

同步:排队执行 , 效率低但是安全。

异步:同时执行 , 效率高但是数据不安全。

并发与并行

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

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

线程池 Executors

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

线程池的好处

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

Java中的四种线程池 . ExecutorService

缓存线程池

/** 缓存线程池.
         *（长度无限制）
         *执行流程∶
         *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());
            }
        });
    }

定长线程池

		/**
         * 定长线程池.
         * (长度是指定的数值)
         * 执行流程:
         * 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());
            }
        });

单线程线程池

        /**
         * 单线程线程池.
         * 执行流程:
         * 1. 判断线程池 的那个线程 是否空闲
         * 2. 空闲则使用
         * 3. 不空闲,则等待 池中的单个线程空闲后 使用
         */
        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());
            }
        });

周期性任务定长线程池

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);
    }

第三种实现线程的方法:Callable

Runnable 与 Callable的相同点

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

Runnable 与 Callable的不同点

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

Callable获取返回值

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

行，如果不调用不会阻塞。

Java并发编程艺术

（1）线程创建的方式

表面看来，创建线程的方式有三四种，但是走进源码我们发现每种创建线程的方式的核心都是在 new Thread() 的进一步封装，如果我们把这些都叫作一种新的方式，那么创建线程的方式便会千变万化、层出不穷，比如 JDK 更新了，它可能会多出几个类，会把new Thread() 重新封装，表面上看又会是一种新的实现线程的方式，透过现象看本质，打开封装后，会发现它们最终都是基于 Runnable 接口或继承 Thread 类实现的。

1）实现 Runnable 接口

public class RunnableThread implements Runnable { 
	@Override
	public void run() {

		System.out.println('用实现 Runnable 接口实现线程');

	} 
}

2）继承 Thread 类

public class ExtendsThread extends Thread { 
	@Override
	public void run() {
		System.out.println('用 Thread 类实现线程');
	} 
}

3）实现 Callable 接口（有返回值）

class CallableTask implements Callable<Integer> { 
	@Override
	public Integer call() throws Exception {
		return new Random().nextInt();
	} 
}
//创建线程池

	ExecutorService service = Executors.newFixedThreadPool(10);

//提交任务，并用 Future 提交返回结果

	Future<Integer> future = service.submit(new CallableTask());