Java线程和线程池

创建线程的方式：继承Thread   、 实现Runnable接口  、实现Callable接口（可以通过Future获取返回结果）

介绍一下通过Callable实现多线程：

public class ThreadC implements Callable {
    public Object call() throws Exception {
        System.out.println("线程执行");
        return "线程返回结果";
    }

    public static void main(String []args){
        ThreadC threadC=new ThreadC();
        FutureTask futureTask=new FutureTask(threadC);
        new Thread(futureTask).start();
        try {
            Object  obj=futureTask.get();
            System.out.println(obj);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//输出结果
线程执行
线程返回结果

线程之间的状态转换（线程的状态：创建  就绪   执行   阻塞   终止）

                  

 

对于线程中常用的方法有：
sleep():当前线程休眠，但对象锁保持不放
wait():，通常在和notify()一起作用在synchronized方法中，在执行完后让线程进入等待队列
notify:唤醒在此对象监听器的线程，如果有多个则随机唤醒一个
yeild():线程让步，暂停当前线程，让同级或更高优先级线程执行
join():当前线程进入阻塞，等待其他线程终止
interrupt():中断线程信号

线程同步:   
线程的特点 ：可见性  有序性   在不同步处理情况下多个线程并发执行的时候造成执行顺序随机，变量数据不可靠

public class ThreadD{
    public  /*synchronized */ void  print(String name){     //传入字符串，按字符输出
        for(int i=0;i<name.length();i++){
            System.out.print(name.charAt(i));
        }
    }
    public  static void main(String []args){
        final ThreadD threadD=new ThreadD();
             Thread a=new Thread(new Runnable() {                   //创建两个线程执行print()方法，预期输出lisizhangsan，不在print方法加synchronized时输出结果就会变得随机
                 public void run() {
                     threadD.print("lisi");
                 }
             });
        Thread b=new Thread(new Runnable() {
            public void run() {
                threadD.print("zhangsan");
            }
        });
             a.start();
             b.start();
    }

}

synchronized关键字的作用域有二种： 
1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法； 
2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。 

2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象； 

3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法； 

该部分文字引入来源:  原文：https://blog.csdn.net/evankaka/article/details/44153709 

如何启动三个线程按顺序打印ABC:

public class ThreadB  implements Runnable{
    private String name;
    private Object pre;
    private Object self;
    public ThreadB(String name, Object pre, Object self) {
        this.name = name;
        this.pre = pre;
        this.self = self;
    }

    public void run() {
        synchronized (pre){
            synchronized (self){
                System.out.println(name);
                    self.notify();
            }
            try {
                pre.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String []args){
        Object a=new Object();
        Object b=new Object();
        Object c=new Object();
        ThreadB ta=new ThreadB("A",b,c);
        ThreadB tb=new ThreadB("B",c,a);
        ThreadB tc=new ThreadB("C",a,b);
        for(int i=0;i<10;i++){
            new Thread(ta).start();
            new Thread(tb).start();
            new Thread(tc).start();
        }
    }
}

 

线程池原理
public ThreadPoolExecutor(int corePoolSize,
                               int maximumPoolSize,
                               long keepAliveTime,
                               TimeUnit unit,
                               BlockingQueue<Runnable> workQueue,
                               RejectedExecutionHandler handler) 

corePoolSize：线程池核心线程数量

maximumPoolSize:线程池最大线程数量

keepAliverTime：当活跃线程数大于核心线程数时，空闲的多余线程最大存活时间

unit：存活时间的单位

workQueue：存放任务的队列

handler：超出线程范围和队列容量的任务的处理程序

线程池的实现原理  文字引入来源： https://www.cnblogs.com/dongguacai/p/6030187.html
提交一个任务到线程池中，线程池的处理流程如下：

1、判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。

2、线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。

3、判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

                                     

 

RejectedExecutionHandler：饱和策略
当队列和线程池都满了，说明线程池处于饱和状态，那么必须对新提交的任务采用一种特殊的策略来进行处理。这个策略默认配置是AbortPolicy，表示无法处理新的任务而抛出异常。JAVA提供了4中策略：

1、AbortPolicy：直接抛出异常

2、CallerRunsPolicy：只用调用所在的线程运行任务

3、DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。

4、DiscardPolicy：不处理，丢弃掉。

ExecutorService threadPool = Executors.newFixedThreadPool(3);// 创建可以容纳3个线程的线程池 

ExecutorService threadPool = Executors.newCachedThreadPool();// 线程池的大小会根据执行的任务数动态分配  

ExecutorService threadPool = Executors.newSingleThreadExecutor();// 创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务  

ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);// 效果类似于Timer定时器