多线程系列：Java创建线程的方式

代码地址：https://pan.baidu.com/s/1gXlw7gumteukBHocQ392sg 提取码：4rnk

继承Thread类重写run方法

/**
* 继承Thread类重写run方法
* 缺点java单继承，继承了Thread后不能继承其他类
* 常见业务单一
*/
static class Thread3Thread extends Thread {
   @Override
   public void run() {
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("cc百川之继承Thread,当前线程名称"+Thread.currentThread().getName());
   }
}

实现Runable类

/**
 * 通过实现Runable的方式
 * 无返回值通过 Thread或者线程池的方式调度
 */
static class  Thread2Runnable implements Runnable{
    @Override
    public void run() {
        System.out.println("cc百川之Runnable");
    }
}
public void test(){
//利用匿名内部类
 new Thread(new Runnable() {
   @Override
       public void run() {
           System.out.println("cc百川之Runnable");
       }
   }).start();
 new Thread(){
       @Override
       public void run() {
           System.out.println("cc百川之Thread");
       }
   }.start();
}

实现Callable

/**
* 通过实现Callable的方式
* 有返回值，通过 FutureTask调度任务或者通过线程池调度任务
* 优点在内部业务执行完毕后，能清楚知道执行结果
*/
static class  Thread1Callable implements Callable {
   @Override
   public Object call() throws Exception {
       System.out.println("cc百川之Callable");
       Thread.sleep(1000);
       return 1>Math.random()*2;
   }
}

利用线程池

public void test(){
	System.out.println("***********");
	ExecutorService es = Executors.newFixedThreadPool(2);
	System.out.println(es.submit(new Thread1Callable()).get());//Thread1Callable call为返回Object方法
	System.out.println(es.submit(new Thread3Thread()).get());//Thread3Thread run为void方法
	System.out.println(es.submit(new Thread2Runnable()).get());//Thread2Runnable run为void方法
	es.shutdown();//关闭
	//        System.out.println(es.shutdownNow());
}
public void testPool(){
//大小设置一般强调cpu的设置为CPU+1
//			强调IO的设置为2*CPU+1
 int corePoolSize = 2;//核心线程数
 int maximumPoolSize = 4;//最大线程数
 long keepAliveTime = 1000L;//允许线程最大空闲时间
 TimeUnit tu =  TimeUnit.MILLISECONDS;//时间单位
 BlockingQueue<Runnable> bq = new ArrayBlockingQueue<>(5);//阻塞队列，保存等待被执行的任务
 ThreadFactory tf = Executors.defaultThreadFactory();//创建线程的工程方法
 RejectedExecutionHandler policy = new ThreadPoolExecutor.AbortPolicy();//拒绝策略
 
 ThreadPoolExecutor e = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, tu, bq, tf, policy);
 System.out.println(e.submit(new Thread1Callable()).get());//Thread1Callable call为返回Object方法
 System.out.println(e.submit(new Thread3Thread()).get());//Thread3Thread run为void方法
 System.out.println(e.submit(new Thread2Runnable()).get());//Thread2Runnable run为void方法
}

常见问题

1.守护线程

守护线程指运行在后台的一种专门服务其他的线程。
当JVM中不存在任何一个非守护线程时，JVM自动退出（关闭）。注意守护线程拥有自动结束自己生命周期的特性。

public class Test1_Deam {

	public static void main(String[] args) throws ExecutionException, InterruptedException {
        for(int i=0;i<1;i++) {
            test();
        }
    }
    static class Thread3Thread extends Thread {
        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("cc百川之继承Thread,当前线程名称"+Thread.currentThread().getName());
        }
    }

    public static void test() throws ExecutionException, InterruptedException {
        Thread3Thread tt = new Thread3Thread();
        Thread t = new Thread(tt, "cc百川线程");
        t.setDaemon(true);//通过setDaemon设置用户线程为守护线程  常见守护线程GC守护线程
        t.start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("cc百川之Thread");
            }
        }).start();
       }
   }

2.线程的生命周期

1. 新建：还没有调用start之前的状态

2. 运行：

   2.1就绪状态：调用对象的start方法，线程处于可运行线程池中，等待被线程调度。
   2.2运行中状态：就绪状态的线程在获得cpu时间片段后变为运行中状态

3. 阻塞：

   3.1等待阻塞：调用wait方法后，把当前线程放入等待池，调用notify或notifyAll后进入锁池参与锁竞争,或者LockSupport.park后等待调用LockSupport.unpark。
   3.2其他阻塞：sleep或join等jvm就把该线程置为阻塞状态。
   3.3同步阻塞：获取锁失败是，jvm把该线程放入锁池中。

4. 死亡：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

3.Callable与Runable区别

1.Runnable没有返回值，Callable可以拿到有返 回值，Callable可以看作是Runnable的补充。
2.Runable用run描述一个任务，Callable用call描述一个任务

4.线程池常见状态

	//处理等待队列中的任务，接受新的任务
    private static final int RUNNING    = -1 << COUNT_BITS;
    //不接受新的任务提交，但会继续处理等待中的任务
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    //不接受新的任务提交，不在处理等待中的任务，中断正在执行的任务线程
    private static final int STOP       =  1 << COUNT_BITS;
    //销毁所有的任务，workcount为0时线程会转为tidying状态时，执行钩子方法terminated()
    private static final int TIDYING    =  2 << COUNT_BITS;
    //rerminated()方法结束后线程的状态
    private static final int TERMINATED =  3 << COUNT_BITS;

可以通过线程池shutdown()方法源码看到这个时候，设置运行线程的标志位SHUTDOWN

5.shutdownNow与shutdown的区别

shutdownNow不接受新的任务提交，不在处理等待中的任务，中断正在执行的任务线程，而shutdown不接受新的任务提交，但会继续处理等待中的任务。

// java/util/concurrent/ThreadPoolExecutor.java
 --------------shutdownNow
public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;//lock显示锁机制，利用CAS,AQS等处理多线程问题， 防止多线程问题 
    mainLock.lock();
    try {
        checkShutdownAccess();//结束检查
        advanceRunState(STOP);//添加STOP结束标志 不接受新任务，不处理等待的任务
        interruptWorkers();//设置interrupted标识
        tasks = drainQueue();//执行结束命令
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
    return tasks;
}
private List<Runnable> drainQueue() {
     BlockingQueue<Runnable> q = workQueue;
     ArrayList<Runnable> taskList = new ArrayList<Runnable>();
     q.drainTo(taskList);
     if (!q.isEmpty()) {
         for (Runnable r : q.toArray(new Runnable[0])) {
             if (q.remove(r))//直接结束
                 taskList.add(r);
         }
     }
     return taskList;
 }
 --------------shutdown
public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(SHUTDOWN);
        interruptIdleWorkers();
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
}
// java/util/concurrent/ScheduledThreadPoolExecutor.java
@Override void onShutdown() {
  BlockingQueue<Runnable> q = super.getQueue();
  boolean keepDelayed =
      getExecuteExistingDelayedTasksAfterShutdownPolicy();
  boolean keepPeriodic =
      getContinueExistingPeriodicTasksAfterShutdownPolicy();
  if (!keepDelayed && !keepPeriodic) {//检查等待的任务
      for (Object e : q.toArray())
          if (e instanceof RunnableScheduledFuture<?>)
              ((RunnableScheduledFuture<?>) e).cancel(false);
      q.clear();
  }
  else {
      // Traverse snapshot to avoid iterator exceptions
      for (Object e : q.toArray()) {
          if (e instanceof RunnableScheduledFuture) {
              RunnableScheduledFuture<?> t =
                  (RunnableScheduledFuture<?>)e;
              if ((t.isPeriodic() ? !keepPeriodic : !keepDelayed) ||
                  t.isCancelled()) { // also remove if already cancelled
                  if (q.remove(t))//结束任务
                      t.cancel(false);
              }
          }
      }
  }
  tryTerminate();
}

6.submit()与execute()区别

execute()用户执行Runable类型的任务，而submit可以执行Runable和Callable类型的任务。

7.sleep()与wait()的区别

1.sleep为线程的静态方法，wait为Objectd的方法
2.sleep会一直占有锁，而wait为释放锁，让其他线程参与获取锁竞争。
3.wait释放后，需要notify或者notifyAll唤醒，而sleep到时间后自动唤醒进入就绪状态

8.线程池的饱和策略

指线程池阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，应该如何处理该任务。

饱和策略	策略说明	策略源码
CallerRunsPolicy ***	由调用者所在的线程来执行任务
DiscardOldestPolicy ***	丢弃阻塞队列中靠最前的任务，并执行当前任务
AbortPolicy （默认策略）	直接抛出异常，默认策略
DiscardPolicy	直接丢弃任务
自定义拒绝策略	按照业务定制自己的策略

---

待补充