多线程

多线程

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

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

 

同步与异步

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

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

并发与并行

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

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

 

线程调度

分时调度

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

抢占式调度

　　优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)， Java使用的为抢占式调度。

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

 

 

线程的实现方式

继承Thread

    public static void main(String[] args) {
        Thread th = new TestThread();
        th.start();
    }

    static class TestThread extends Thread {
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println(i);
            }
        }
    }

 

实现Runnable

    public static void main(String[] args) {
        TestRun tr = new TestRun();
        new Thread(tr).start();
    }

    static class TestRun implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 6; i++) {
                System.out.println(i + 1);
            }
        }
    }

 

实现Callable接口

public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCall tc = new TestCall();
        FutureTask futureTask = new FutureTask(tc);
        new Thread(futureTask).start();
        // get获取线程执行的结果，会阻塞主进程继续执行，
        // 此处调用get方法，得到的结果为： 0 1 2  7 8 9
        //     即得到了线程的执行结果后，才会继续执行之后的代码
        futureTask.get();
        for (int i = 7; i < 10; i++) {
            System.out.println(i);
        }
    }

    static class TestCall implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            int i;
            for (i = 0; i < 3; i++) {
                System.out.println(i);
            }
            return i;
        }
    }

 

Runnable 与 Callable

相同点

都是接口

都可以编写多线程程序

都采用Thread.start()启动线程

 

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

 

 

 

线程池（Executors）

提供了一个线程队列，队列中保存着所有等待状态的线程，可以反复使用。

使用线程池避免了创建与销毁线程的额外开销，提高了程序响应的速度。

 

线程池的好处

　　降低资源消耗。

　　提高响应速度。

　　提高线程的可管理性。

 

四种线程池

缓存线程池

        /**
         * 缓存线程池.
         * (长度无限制)
         * 执行流程:
         * 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. 空闲则使用
         * 4. 不空闲,则等待 池中的单个线程空闲后 使用
         * 
         * 效果与定长线程池 创建时传入数值1 效果一致.
        */
        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());
            }
        });

 

周期性任务定长线程池

        /**
         * 周期任务 定长线程池.
         * 执行流程:
         * 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);