多线程技术概述

线程与进程

        进程

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

        线程

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

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

线程调度

        

        分时调度

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

        抢占式调度

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

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

同步与异步

        同步

                 ·排队执行 , 效率低但是安全。 

        异步

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

并发与并行

        并发

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

        并行

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

守护线程和用户线程

        守护线程

                        ·守护用户线程，当最后一个用户线程结束，守护线程自动死亡。

        用户线程

                        ·独立存在的，不会因为其他用户线程退出而退出。

线程池 Executors

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

        线程池技术接受Runnable,不接受Thread。

线程池的好处

        

        ·降低资源消耗。

        ·提高响应速度。

        ·提高线程的可管理性。

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

Runnable 与 Callable

接口定义 
//Callable接口 

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

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

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() 得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。