多线程

为什么用线程池

有时候系统需要处理非常多的执行时间很短的请求，如果每一个请求开启一个新线程的话，系统就会不断的进行线程的创建与销毁，有时花在线程的创建与销毁的时间比真正线程执行的时间要长。

而且当线程数量太多时，线程不一定受得了

使用线程池主要是解决以下几个问题：

通过用线程池中的线程，来减少每个线程创建和销毁的性能开销

对线程进行一些维护管理，比如定是开始、周期执行，并发数控制等等

线程池参数

1、corePoolSize：核心线程数
        * 核心线程会一直存活，及时没有任务需要执行
        * 当线程数小于核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理
        * 设置allowCoreThreadTimeout=true（默认false）时，核心线程会超时关闭

    2、queueCapacity：任务队列容量（阻塞队列）
        * 当核心线程数达到最大时，新任务会放在队列中排队等待执行

    3、maxPoolSize：最大线程数
        * 当线程数>=corePoolSize，且任务队列已满时。线程池会创建新线程来处理任务
        * 当线程数=maxPoolSize，且任务队列已满时，线程池会拒绝处理任务而抛出异常

    4、 keepAliveTime：线程空闲时间
        * 当线程空闲时间达到keepAliveTime时，线程会退出，直到线程数量=corePoolSize
        * 如果allowCoreThreadTimeout=true，则会直到线程数量=0    5、allowCoreThreadTimeout：允许核心线程超时
    6、rejectedExecutionHandler：任务拒绝处理器
        * 两种情况会拒绝处理任务：
            - 当线程数已经达到maxPoolSize，切队列已满，会拒绝新任务
            - 当线程池被调用shutdown()后，会等待线程池里的任务执行完毕，再shutdown。如果在调用shutdown()和线程池真正shutdown之间提交任务，会拒绝新任务
        * 线程池会调用rejectedExecutionHandler来处理这个任务。如果没有设置默认是AbortPolicy，会抛出异常
        * ThreadPoo
lExecutor类有几个内部实现类来处理这类情况：
            - AbortPolicy 丢弃任务，抛运行时异常
            - CallerRunsPolicy 执行任务
            - DiscardPolicy 忽视，什么都不会发生
            - DiscardOldestPolicy 从队列中踢出最先进入队列（最后一个执行）的任务
        * 实现RejectedExecutionHandler接口，可自定义处理器ThreadPoolExecutor执行顺序       

public class Thred {
    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {

                try {
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName()+"run");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        ThreadPoolExecutor executor = new ThreadPoolExecutor(3,6,2,TimeUnit.SECONDS,new SynchronousQueue<>());
//        ThreadPoolExecutor executor = new ThreadPoolExecutor(3,6,2,TimeUnit.SECONDS,new LinkedBlockingDeque<>());
//        ThreadPoolExecutor executor = new ThreadPoolExecutor(3,6,2,TimeUnit.SECONDS,new LinkedBlockingDeque<>(4));
        executor.execute(runnable);
        executor.execute(runnable);
        executor.execute(runnable);
        System.out.println("开启三个线程");
        System.out.println("核心线程数:"+executor.getCorePoolSize());
        System.out.println("线程池数："+executor.getPoolSize());
        System.out.println("任务队列数："+executor.getQueue().size());
        Thread.sleep(2000);
        executor.execute(runnable);
        executor.execute(runnable);
        executor.execute(runnable);
        executor.execute(runnable);
        executor.execute(runnable);
        executor.execute(runnable);
        System.out.println("再开启6个线程");
        System.out.println("核心线程数:"+executor.getCorePoolSize());
        System.out.println("线程池数："+executor.getPoolSize());
        System.out.println("任务队列数："+executor.getQueue().size());
    }

}

线程池按以下行为执行任务

如果线程数量<=核心线程数，那么直接启动核心线程来执行任务，不会放到队列里面

如果线程数量>核心线程数量，但<最大线程数量，那么LinkedBlockingDeque超过核心线程数量的线程会放到队列里面排队

如果线程数量>核心线程数量，但<最大线程数量，那么SynchronousQueue会创建新的线程执行任务，不会放在任务队列中，这些线程属于非核心线程，在任务完成后，闲置时间达到了超时时间会被清除

如果线程数量>核心线程数量，并且>最大线程数量，当任务队列是LinkedBlockingDeque，会将超过核心线程放到任务队列，也就是说当任务队列是LinkedBlockingDeque，线程最大数量设置是无效的，他的线程最大不会超过线程数

如果线程数量>核心线程数量，并且>最大线程数量，当任务队列是SynchronousQueue，会因为线程池拒绝添加任务而抛出异常

当任务队列大小有限制时： 

当LinkedBlockingDeque被塞满时，新增的任务会直接创建线程执行，当创建的线程数量超过最大线程数量时，抛出异常

SynchronousQueue，没有数量限制，因为他根本不保持这些任务，直接交给线程池去执行，当任务超出最大线程数时抛出异常

用过AtomicInteger吗？怎么用的？

AtomicInteger是int的原子操作类，对全局变量的数值类型操作num++，若没有加synchronized关键字，则认为线程是不安全的

public class Atomic {
    public static  int count=0;
    public static void main(String[] args) throws InterruptedException {

      for (int i =0;i<10000;i++){
          new Thread(){
              public void run(){
                  count++;
              }
          }.start();
      }
      Thread.sleep(2000);
      System.out.println(count);
    }
}
//线程不安全，输出9999，或10000，或其他，输出正确靠碰运气

加关键字volatile，仅仅保证变量在线程间保持可见性，却并不保证原子性操作

public class Atomic {
    public static volatile  int count=0;
    public static void main(String[] args) throws InterruptedException {

      for (int i =0;i<10000;i++){
          new Thread(){
              public void run(){
                  count++;
              }
          }.start();
      }
      Thread.sleep(2000);
      System.out.println(count);
    }
}
//同样，输出9999，或10000，或其他，输出正确靠碰运气

AtomicInteger是int的原子操作类 

public class Atomic {
    public static AtomicInteger count = new AtomicInteger(0);
    public static void main(String[] args) throws InterruptedException {

      for (int i =0;i<10000;i++){
          new Thread(){
              public void run(){
                  count.getAndIncrement();
              }
          }.start();
      }
      Thread.sleep(2000);
      System.out.println(count);
    }
}

 AtomicInteger常用方法

用过ThreadLocal吗？

多线程有哪几种创建方式

1.继承Thread类创建线程

public class ThreadGreatTest extends Thread {
    public void run(){
        System.out.println("线程run");
    }

    public static void main(String[] args) {
        ThreadGreatTest threadGreatTest = new ThreadGreatTest();
        threadGreatTest.start();
//        或者
        new ThreadGreatTest().start();
    }
}

2.实现Rannable接口创建线程

参考文章前面代码，前面有写过

3.实现Callable接口通过FutureTask包装器来创建Thread线程

public class ThreadGreatTest2 extends Thread {

    public static void main(String[] args) {
        Callable callable = new ThreadGreatTest21();
        FutureTask futureTask = new FutureTask(callable);
        Thread t = new Thread(futureTask);
        //线程1执行
        t.start();
        //线程2执行
        new Thread(new FutureTask(callable)).start();
    }
}


=========================================================

public class ThreadGreatTest21 implements Callable {

    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"通过实现Callable接口通过FutureTask包装器来实现线程");
        return null;
    }
}

4.使用ExecutorService、Callable、Future实现有返回结果的线程

略

Thread类有没有实现Runable接口

有实现

当调用一个线程的start方法后，线程马上进行运行状态吗？

不是的，只是进入就绪（可运行）状态，等待分配cpu时间片，一旦得到cup时间片，即进入运行状态

线程的几种状态

1、新建状态(New)：新创建了一个线程对象。

2、就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于“可运行线程池”中，变得可运行，只等待获取CPU的使用权。即在就绪状态的进程除CPU之外，其它的运行所需资源都已全部获得。

3、运行状态(Running)：就绪状态的线程获取了CPU，执行程序代码。

4、阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。

阻塞的情况分三种：

(1)、等待阻塞：运行的线程执行wait()方法，该线程会释放占用的所有资源，JVM会把该线程放入“等待池”中。进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒，

(2)、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入“锁池”中。

(3)、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5、死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期

说说sleep、yield、wait、join的区别

1.sleep()方法

在指定时间内让当前正在执行的线程暂停执行，但不会释放“锁标志”。不推荐使用。

sleep()使当前线程进入阻塞状态，在指定时间内不会执行。

2.wait()方法

在其他线程调用对象的notify或notifyAll方法前，导致当前线程等待。线程会释放掉它所占有的“锁标志”，从而使别的线程有机会抢占该锁。

当前线程必须拥有当前对象锁。如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常。

唤醒当前对象锁的等待线程使用notify或notifyAll方法，也必须拥有相同的对象锁，否则也会抛出IllegalMonitorStateException异常。

waite()和notify()必须在synchronized函数或synchronized　block中进行调用。如果在non-synchronized函数或non-synchronized　block中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。

3.yield方法

暂停当前正在执行的线程对象。

yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

yield()只能使同优先级或更高优先级的线程有执行的机会。 

4.join方法

等待该线程终止。

等待调用join方法的线程结束，再继续执行。如：t.join();//主要用于等待t线程运行结束，若无此句，main则会执行完毕，导致结果不可预测。