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

淡淡的烟草味﹌ 2022-11-16 05:57 365阅读 0赞

### Java常见创建线程的方式 ###

*  继承Thread类重写run方法
 *  实现Runable类
 *  实现Callable
 *  利用线程池
 *  常见问题
 *   *  1.守护线程
     *  2.线程的生命周期
     *  3.Callable与Runable区别
     *  4.线程池常见状态
     *  5.shutdownNow与shutdown的区别
     *  6.submit()与execute()区别
     *  7.sleep()与wait()的区别
     *  8.线程池的饱和策略

代码地址：[https://pan.baidu.com/s/1gXlw7gumteukBHocQ392sg][https_pan.baidu.com_s_1gXlw7gumteukBHocQ392sg] 提取码：4rnk  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70]

# 继承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;
       }
    }

# 利用线程池 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70 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();
           }
       }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70 3]

## 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  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70 4]

## 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到时间后自动唤醒进入就绪状态  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70 5]

## 8.线程池的饱和策略 ##

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

<table> 
 <thead> 
  <tr> 
   <th>饱和策略</th> 
   <th>策略说明</th> 
   <th>策略源码</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>CallerRunsPolicy ***</td> 
   <td>由调用者所在的线程来执行任务</td> 
   <td><img src="https://img-blog.csdnimg.cn/20210407134028132.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI=,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>DiscardOldestPolicy ***</td> 
   <td>丢弃阻塞队列中靠最前的任务，并执行当前任务</td> 
   <td><img src="https://img-blog.csdnimg.cn/20210407133902373.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI=,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>AbortPolicy （默认策略）</td> 
   <td>直接抛出异常，默认策略</td> 
   <td><img src="https://img-blog.csdnimg.cn/20210407133941133.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI=,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>DiscardPolicy</td> 
   <td>直接丢弃任务</td> 
   <td><img src="https://img-blog.csdnimg.cn/20210407134105721.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI=,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>自定义拒绝策略</td> 
   <td>按照业务定制自己的策略</td> 
   <td><img src="https://img-blog.csdnimg.cn/20210407135646496.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI=,size_16,color_FFFFFF,t_70" alt="在这里插入图片描述"></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

--------------------

待补充

[https_pan.baidu.com_s_1gXlw7gumteukBHocQ392sg]: https://pan.baidu.com/s/1gXlw7gumteukBHocQ392sg
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70]: /images/20221022/4edb10493abd456f91910959cd5cf7dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70 1]: /images/20221022/446fadf5b873460298f7a5dffb18b0db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70 2]: /images/20221022/4c70050cd3734565965a89f91ef30607.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70 3]: /images/20221022/cfd94c3c87b24d389e4d213e86f976b2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70 4]: /images/20221022/4bc7ea103a324185adf59eb3c980ba76.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqY2MxMjI_size_16_color_FFFFFF_t_70 5]: /images/20221022/7c166e1ae827414fa969929143922778.png