精华内容
下载资源
问答
  • java 创建线程的三种方式、创建线程池四种方式

    万次阅读 多人点赞 2019-02-23 21:01:44
    概要: java创建线程的三种方式: ...java创建线程池四种方式: newCachedThreadPool 创建一个可缓存的线程池,如果线程池长度超过处理需求,可灵活回收空闲线程,若无可回收,则新建线程 newFixedThread...

    概要:

    java创建线程的三种方式:

    1.     继承Thread类创建线程类
    2.     实现Runnable接口
    3.     通过Callable和Future创建线程

       

    java创建线程池的四种方式:

         newCachedThreadPool 创建一个可缓存的线程池,如果线程池长度超过处理需求,可灵活回收空闲线程,若无可回收,则新建线程

        newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待

        newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行

        newSingleThreadExecutor 创建一个单线程化的线程池,它只会唯一的工作线程来执行任务,保证所有任务按照指定

    顺序(FIFO,LIFO,优先级)执行

     

    线程池的优点:

         a. 重用存在的线程,减少对象创建、消亡的开销,性能佳
         b. 可有效控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞。
         c. 提供定时执行、定期执行、单线程、并发数控制等功能。

     

    第一 Java中创建线程主要有三种方式:

    1、继承Thread类创建线程类 (extends)

    (1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体(线程体)

    (2)创建Thread子类的实例,即创建了线程对象。

    (3)调用线程对象的start()方法来启动该线程。  

      
    public class FirstThreadTest extends Thread{  
        int i = 0;  
        //重写run方法,run方法的方法体就是现场执行体  
        public void run()  
        {  
            for(;i<100;i++){  
            log.info(getName()+"  "+i);  
            }  
        }  
    
        public static void main(String[] args)  
        {  
            for(int i = 0;i< 100;i++)  
            {  
                log.info(Thread.currentThread().getName()+"  : "+i);  
                if(i==20)  
                {  
                    new FirstThreadTest().start();  
                    new FirstThreadTest().start();  
                }  
            }  
        }  
    } 

     

    上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。

     

    2、通过Runnable接口创建线程类

    (1)定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。

    (2)创建 Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。

    (3)调用线程对象的start()方法来启动该线程。

    public class RunnableThreadTest implements Runnable  
    {  
      
        private int i;  
        public void run()  
        {  
            for(i = 0;i <100;i++)  
            {  
               log.info(Thread.currentThread().getName()+" "+i);  
            }  
        }  
    
        public static void main(String[] args)  
        {  
            for(int i = 0;i < 100;i++)  
            {  
                log.info(Thread.currentThread().getName()+" "+i);  
                if(i==20)  
                {  
                    RunnableThreadTest runner= new RunnableThreadTest();  
                    new Thread(runner,"新线程1").start();  
                    new Thread(runner,"新线程2").start();  
                }  
            }  
        }   
    }  

     

    线程的执行流程很简单,当执行代码start()时,就会执行对象中重写的void run()方法,该方法执行完成后,线程就消亡了。

     

    3、通过Callable和Future创建线程

    (1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值

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

    (2)创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方

    法的返回值。(FutureTask是一个包装器,它通过接受Callable来创建,它同时实现了Future和Runnable接口。)

    (3)使用FutureTask对象作为Thread对象的target创建并启动新线程。

    (4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

    public class CallableThreadTest implements Callable<Integer>  
    {  
      
        public static void main(String[] args)  
        {  
            CallableThreadTest ctt = new CallableThreadTest();  
            FutureTask<Integer> ft = new FutureTask<>(ctt);  
            for(int i = 0;i < 100;i++)  
            {  
                log.info(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
                if(i==20)  
                {  
                    new Thread(ft,"有返回值的线程").start();  
                }  
            }  
            try  
            {  
                log.info("子线程的返回值:"+ft.get());  
            } catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            } catch (ExecutionException e)  
            {  
                e.printStackTrace();  
            }  
      
        }  
      
        @Override  
        public Integer call() throws Exception  
        {  
            int i = 0;  
            for(;i<100;i++)  
            {  
                log.info(Thread.currentThread().getName()+" "+i);  
            }  
            return i;  
        }  
      
    }  

     

    二、创建线程的三种方式的对比

    1、采用实现Runnable、Callable接口的方式创建多线程

          优势:

           线程类只是实现了Runnable接口或Callable接口,还可以继承其他类。

           在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。

           劣势

         编程稍微复杂,如果要访问当前线程,则必须使用Thread.currentThread()方法

    2、使用继承Thread类的方式创建多线程

          优势:

          编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程

          劣势:

          线程类已经继承了Thread类,所以不能再继承其他父类。

    3、Runnable和Callable的区别

         (1) Callable规定(重写)的方法是call(),Runnable规定(重写)的方法是run()。

         (2) Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。

         (3) call方法可以抛出异常,run方法不可以。

         (4) 运行Callable任务可以拿到一个Future对象,表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的

    完成,并检索计算的结果。通过Future对象可以了解任务执行情况,可取消任务的执行,还可获取执行结果future.get()。

     

    第二 创建四种线程池的方式

    1、new Thread的弊端

    执行一个异步任务你还只是如下new Thread吗?

    new Thread(new Runnable() {
    
    
      @Override
    
      public void run() {
    
        // TODO Auto-generated method stub
    
        }
    
      }
    
    ).start();

     

    那你就out太多了,new Thread的弊端如下:

         a. 每次new Thread新建对象性能差
         b. 线程缺乏统一管理,可能无限制新建线程,相互之间竞争,及可能占用过多系统资源导致死机或oom(out of memory)。
         c. 缺乏更多功能,如定时执行、定期执行、线程中断。

    相比new Thread,Java提供的四种线程池的好处在于:

              a. 重用存在的线程,减少对象创建、消亡的开销,性能佳
              b. 可有效控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞。
              c. 提供定时执行、定期执行、单线程、并发数控制等功能。

    2、Java 线程池

    Java通过Executors提供四种线程池,分别为:

    newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
    newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
    newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。
    newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。


    (1) newCachedThreadPool:

    创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。示例代码如下:

    ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
    
      for (int i = 0; i < 10; i++) {
    
        final int index = i;
    
      try {
    
        Thread.sleep(index * 1000);
    
       } catch (InterruptedException e) {
    
          e.printStackTrace();
    
      }
    
    
    
       cachedThreadPool.execute(new Runnable() {
    
         @Override
    
         public void run() {
    
            log.info(index);
    
          }
    
       });
    
    }

    线程池为无限大,当执行第二个任务时第一个任务已经完成,会复用执行第一个任务的线程,而不用每次新建线程。

     

    (2) newFixedThreadPool:---  需要指定线程池的大小

    创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。示例代码如下:

    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
    
      for (int i = 0; i < 10; i++) {
    
      final int index = i;
    
    
      fixedThreadPool.execute(new Runnable() {
    
    
      @Override
    
      public void run() {
     
          try {
             log.info(index);
             Thread.sleep(2000);
          } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
           }
        }
      });
    }

    因为线程池大小为3,每个任务输出index后sleep 2秒,所以每两秒打印3个数字。

    定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。可参考PreloadDataCache。

     

    (3)newScheduledThreadPool:

    创建一个定长线程池,支持定时及周期性任务执行。延迟执行示例代码如下:

    ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
    
     scheduledThreadPool.schedule(new Runnable() {
    
    
          @Override
    
          public void run() {
    
             log.info("delay 3 seconds");
           }
    
     }, 3, TimeUnit.SECONDS);

    表示延迟3秒执行。

    定期执行示例代码如下:

    scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
    
          @Override
    
          public void run() {
    
              log.info("delay 1 seconds, and excute every 3 seconds");
    
          }
    
    }, 1, 3, TimeUnit.SECONDS);

    表示延迟1秒后每3秒执行一次。

    ScheduledExecutorService比Timer更安全,功能更强大

     

    (4)newSingleThreadExecutor:

    创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下:

    ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
    
    for (int i = 0; i < 10; i++) {
      final int index = i;
      singleThreadExecutor.execute(new Runnable() {
    
        @Override
        public void run() {
        try {
            log.info(index);
            Thread.sleep(2000);
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
        }
      });
    }

    结果依次输出,相当于顺序执行各个任务。

    线程池的作用:

    线程池作用就是限制系统中执行线程的数量。

    根据系统的环境情况,可以自动或手动设置线程数量,达到运行的最佳效果;少了浪费了系统资源,多了造成系统拥挤效率

    不高。用线程池控制线程数量,其他线程排队等候。一个任务执行完毕,再从队列的中取最前面的任务开始执行。若队列中没

    有等待进程,线程池的这一资源处于等待。当一个新任务需要运行时,如果线程池中有等待的工作线程,就可以开始运行了;

    否则进入等待队列。

    为什么要用线程池:

    1.减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可执行多个任务。

    2.可以根据系统的承受能力,调整线程池中工作线线程的数目,防止因为消耗过多的内存,而把服务器累趴下(每个线程需要大

    约1MB内存,线程开的越多,消耗的内存也就越大,最后死机)。

    Java里面线程池的顶级接口是Executor,但是严格意义上讲Executor并不是一个线程池,而只是一个执行线程的工具。真正的

    线程池接口是ExecutorService。

    比较重要的几个类:

    ExecutorService: 真正的线程池接口。

    ScheduledExecutorService: 能和Timer/TimerTask类似,解决那些需要任务重复执行的问题。

    ThreadPoolExecutor: ExecutorService的默认实现。

    ScheduledThreadPoolExecutor: 继承ThreadPoolExecutor的ScheduledExecutorService接口实现,周期性任务调度的类实现。

    要配置一个线程池是比较复杂的,尤其是对于线程池的原理不是很清楚的情况下,很有可能配置的线程池不是较优的,因此

    在Executors类里面提供了一些静态工厂,生成一些常用的线程池。

    展开全文
  • 创建线程池四种方式

    万次阅读 2019-02-22 09:41:40
    Java通过Executors提供四种线程池,分别为: newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。 newFixedThreadPool 创建一个定长线程池,可...

    Executors创建的4种线程池的使用

    Java通过Executors提供四种线程池,分别为:
    newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
    newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
    newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。
    newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

    注意:线程池只是为了控制应用中处理某项业务中防止高并发问题带来的线程不安全的发生的概率。在我目前的测试用,还没有发现线程可以重用这个概念,因为线程开启后,用完就关闭了,不可以再次开启的,查看源码发现会每次新创建一个线程用来处理业务。我们可以通过线程池指定处理这项业务最大的同步线程数,比如:Executors.newFixedThreadPool(3);在线程池中保持三个线程可以同时执行,但是注意,并不是说线程池中永远都是这三个线程,只是说可以同时存在的线程数,当某个线程执行结束后,会有新的线程进来。newFixedThreadPool.execute(new ThreadForpools());这句话的含义并不是添加新的线程,而是添加新的处理业务请求进来。至少我当前是这么理解的,没有发现线程可以重复使用。

    处理线程代码:

    复制代码
    package com.alivn.sockets;
    /**

    • Created by Alivn on 2017/3/19.
      */
      public class ThreadForpools implements Runnable{

      private Integer index;
      public ThreadForpools(Integer index)
      {
      this.index=index;
      }
      @Override
      public void run() {
      /***
      * 业务…省略
      /
      try {
      System.out.println(“开始处理线程!!!”);
      Thread.sleep(index
      100);
      System.out.println(“我的线程标识是:”+this.toString());
      } catch (InterruptedException e) {
      e.printStackTrace();
      }
      }
      }
      复制代码
      (1) newCachedThreadPool
      创建一个可缓存线程池,应用中存在的线程数可以无限大

    示例代码如下:

    复制代码
    package com.alivn.sockets;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    /**

    • Created by Alivn on 2017/3/19.
      */
      public class Threadpools {

      /**

      • 我们获取四次次线程,观察4个线程地址
      • @param args
        /
        public static void main(String[]args)
        {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        System.out.println("newCachedThreadPool
        **");
        for(int i=0;i<4;i++)
        {
        final int index=i;
        newCachedThreadPool.execute(new ThreadForpools(index));
        }
        }
        }
        复制代码
        输出结果是:可以有无限大的线程数进来(线程地址不一样)

    111111

    (2) newFixedThreadPool
    创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。示例代码如下:

    复制代码
    package com.alivn.sockets;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    /**

    • Created by Alivn on 2017/3/19.
      */
      public class Threadpools {

      /**

      • 我们获取四次次线程,观察4个线程地址
      • @param args
        /
        public static void main(String[]args)
        {
        //线程池允许同时存在两个线程
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(2);
        System.out.println("newFixedThreadPool
        **");
        for(int i=0;i<4;i++)
        {
        final int index=i;
        newFixedThreadPool.execute(new ThreadForpools(index));
        }
        }
        }
        复制代码
        输出结果:每次只有两个线程在处理,当第一个线程执行完毕后,新的线程进来开始处理(线程地址不一样)

    222

    (3) newScheduledThreadPool
    创建一个定长线程池,支持定时及周期性任务执行。延迟执行示例代码如下:

    复制代码
    package com.alivn.sockets;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;

    /**

    • Created by Alivn on 2017/3/19.
      */
      public class Threadpools {

      /**

      • 我们获取四次次线程,观察4个线程地址
      • @param args
        /
        public static void main(String[]args)
        {
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(2);
        System.out.println("newFixedThreadPool
        **");
        for(int i=0;i<4;i++)
        {
        final int index=i;
        //延迟三秒执行
        newScheduledThreadPool.schedule(new ThreadForpools(index),3, TimeUnit.SECONDS);
        }
        }
        }
        复制代码
        执行结果:延迟三秒之后执行,除了延迟执行之外和newFixedThreadPool基本相同,可以用来执行定时任务

    333

    1. newSingleThreadExecutor
      创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下:

    复制代码
    package com.alivn.sockets;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;

    /**

    • Created by Alivn on 2017/3/19.
      */
      public class Threadpools {

      /**

      • 我们获取四次次线程,观察4个线程地址
      • @param args
        /
        public static void main(String[]args)
        {
        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
        System.out.println("newFixedThreadPool
        **");
        for(int i=0;i<4;i++)
        {
        final int index=i;
        newSingleThreadExecutor.execute(new ThreadForpools(index));
        }
        }
        }
        复制代码

    执行结果:只存在一个线程,顺序执行

    展开全文
  • 四种多线程对比(异步) 创建和初始化多线程的几种方式 1、继承Thread 2、实现Runnable接口 3、实现Callable接口 + FutureTask(可以拿到返回结果,可以处理异常) 4、线程池 1、方式一:继承 Thread 类 ...

    四种多线程对比(异步)

                  创建和初始化多线程的几种方式
         
           1、继承Thread
           2、实现Runnable接口
           3、实现Callable接口 + FutureTask(可以拿到返回结果,可以处理异常)
           4、线程池
    

    1、方式一:继承 Thread 类

    public class ThreadTest {
        public static void main(String[] args) {
            System.out.println("main...start....");
     
            Thread1 thread1 = new Thread1();
            thread1.start();
    
            System.out.println("main...end....");
        }
    
    
        public static class Thread1 extends Thread {
            @Override
            public void run() {
                System.out.println("当前线程:" + Thread.currentThread().getId());
                int i = 10 / 2;
                System.out.println("运行结果:" + i);
            }
        }
    }
    

    在这里插入图片描述

    2、方式二:实现 Runnable 接口

    public class ThreadTest {
        public static void main(String[] args) {
            System.out.println("main...start....");
    
            //2、实现Runnable接口
            Runable01 runable01 = new Runable01();
            new Thread(runable01).start();
    
            System.out.println("main...end....");
        }
    
        public static class Runable01 implements Runnable {
    
            @Override
            public void run() {
                System.out.println("当前线程:" + Thread.currentThread().getId());
                int i = 10 / 2;
                System.out.println("运行结果:" + i);
            }
        }
    }
    

    在这里插入图片描述

    3、方式三:实现Callable接口 + FutureTask(可以拿到返回结果,可以处理异常)

    public class ThreadTest {
        public static void main(String[] args) {
            System.out.println("main...start....");
    
            //3、实现Callable接口 + FutureTask(可以拿到返回结果,可以处理异常)
            FutureTask<Integer> futureTask = new FutureTask<>(new Callable01());
            new Thread(futureTask).start();
    
            // 阻塞等待整个线程执行完成,获取返回结果
            Integer integer = futureTask.get();
    
            System.out.println("main...end...."+integer);
        }
    
        public static class  Callable01 implements  Callable<Integer> {
    
            @Override
            public Integer call() throws Exception {
                System.out.println("当前线程:" + Thread.currentThread().getId());
                int i = 14 / 2;
                System.out.println("运行结果:" + i);
                return i;
            }
        }
    }
    
    

    在这里插入图片描述

    4、线程池

    我们以后的业务代码里,以上三种启动线程的方方式都不用

    以上三种方式,其实就是一种方式,就是一直创建对象,如下代码

    new Thread(()-> System.out.println("hello")).start();
    

    总结:将所有的多线程异步任务都交给线程池执行

    package com.ctra.gulimall.search.thread;
    
    import java.util.TreeMap;
    import java.util.concurrent.*;
    
    public class ThreadTest {
    	// 创建全局线程池
        public static ExecutorService service = Executors.newFixedThreadPool(10);
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            System.out.println("main...start....");
    
            // 4、线程池
    
            // 整个系统一两个线程池,每个异步任务,提交给线程池让他自己去执行就行
            service.execute(new Runable01());
            System.out.println("main...end....");
        }
    }
    
    

    在这里插入图片描述

    service(线程池) 中可以使用 submiit 和 execute 来存入线程,对比一个有返回值一个无返回值

    在这里插入图片描述

    5、开发中为什么使用写线程池

    在这里插入图片描述

    展开全文
  • Java通过Executors提供四种线程池,分别为: //创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。 ExecutorService pool =Executors.newCachedThreadPool //创建一...
    Java通过Executors提供四种线程池,分别为:
    //创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
    ExecutorService pool =Executors.newCachedThreadPool
    //创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
    ExecutorService pool =Executors.newFixedThreadPool 
    //创建一个定长线程池,支持定时及周期性任务执行。
    ExecutorService pool =Executors.newScheduledThreadPool 
    //创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
    ExecutorService pool =Executors.newSingleThreadExecutor 
    //匿名内部类的方式启动线程
     pool.execute(new Runnable() {
    				public void run() {	
                        //线程执行代码			
    				}
    			});
    //关闭线程
    pool.shutdown();
    
     

     

    展开全文
  • 1、newCachedThreadPool 创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。 2、newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列...
  • 016.多线程-线程池四种创建方式

    千次阅读 2018-11-19 19:19:47
    为什么要用线程池 经常创建、销毁 线程,将是对系统资源的极大浪费。 因此,实际开发中我们将使用线程池来管理、复用 线程。 使用线程池,可以 1.降低资源消耗: 重复利用线程,减少创建和销毁造成的消耗。 2....
  • 线程池介绍及创建线程池的4方式

    万次阅读 多人点赞 2019-06-10 16:40:27
    1. 什么是线程池 Java中的线程池是运用场景最多的并发框架,几乎所有需要异步或并发执行任务的程序 都可以使用线程池。在开发过程中,合理地使用线程池能够带来3个好处。 第一:降低资源消耗。通过重复利用已创建的...
  • java线程池四种创建方式

    千次阅读 2017-07-19 19:54:23
    创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。newCachedThreadPool ◆创建一个定长的线程池,可控制线程最大并发数,超出的线程会在队列中等待。...
  • Java多线程-四种线程池创建方式

    千次阅读 2020-01-15 20:35:21
    一)线程池简介 ...原理:创建一个固定数量大小的线程池,当线程任务数超过固定大小时,未执行的线程任务进行阻塞队列,等待线程池调度。 示例: import java.util.concurrent.ExecutorService; i...
  • Java 创建线程池四种方法

    万次阅读 2018-04-26 10:38:45
    Java通过Executors提供四种线程池,分别为:newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。newFixedThreadPool 创建一个定长线程池,可控制...
  • 关于三种线程池的三队列区别:SynchronousQueue、LinkedBlockingQueue 和...在此记录一下,线程池创建有4方式; 1 .Executors.newCachedThreadPool(); 构造方法为: public static ExecutorService ne
  • Java通过Executors提供四种线程池,分别为: newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。 newFixedThreadPool 创建一个定长线程池,可...
  • Java中Executors类中几种创建各类型线程池方法及简单实例
  • 线程池的4种创建方式

    2019-12-20 14:38:11
    线程池四种创建方式 Java通过Executors(jdk1.5并发包)提供四种线程池,分别为: newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。 ...
  • 执行一个异步任务你还只是new Thread吗? 那你就out了,new Thread有很多的弊端: a.... b. 线程缺乏统一管理,可能无限制新建线程,相互之间竞争,及可能占用过多系统资源导致死机...Java通过Executors提供四种线程池...
  • 二、Executors中线程池创建的4方式 newFixedThreadPool:创建的是定长的线程池,可以控制线程最大并发数,超出的线程会在线程队列中等待,使用的是无界队列,核心线程数和最大线程数一样,当线程池中的线程没有...
  • 线程池四种创建方式

    千次阅读 2019-09-17 16:11:23
    这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用,还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。 例如,线程数一般取...
  • 线程池是一多线程处理形式,处理过程中将任务添加到队列,然后在创建线程后自动启动这些任务。 使用线程池的好处: 1、降低资源开销 (线程的创建和销毁的开销巨大,而通过线程池的重用大大的减少了这些不必要的...
  • 线程池是指在初始化一个多线程应用程序过程中创建一个线程集合,然后在需要执行新的任务时重用这些线程而不是新建一个线程。线程池中线程的数量通常完全取决于可用内存数量和应用程序的需求。然而,增加可用线程数量...
  • 每次启动一个线程都要创建一个新的浪费资源,还有时间线程过多的时候会造成服务器崩溃,所有有了线程池来管理线程,下面介绍几常见创建线程的方式: 一、创建大小不固定的线程池 这是具有缓冲功能的线程池,...
  • 为什么要使用线程池;常见的创建线程池的4方式

    万次阅读 多人点赞 2018-04-14 17:51:49
    1. 为什么使用线程池诸如 Web 服务器、数据库服务器、文件服务器或邮件服务器之类的许多服务器应用程序都面向处理来自某些远程来源的大量短小的任务。请求以某种方式到达服务器,这种方式可能是通过网络协议...
  • 最基本的创建并开启线程的方式: 1. new Thread  [java] view plain copy  print? new Thread(new Runnable() {   @Override   public void run() {   // TODO Auto-...
  • 众所周知,我们在创建线程时有四种方法可以用,分别是: 1、继承Thread类创建线程 2、实现Runnable接口创建线程 3、使用Callable和Future创建线程 4、使用线程池创建(使用java.util.concurrent.Executor接口) 其中...
  • Java线程池四种用法与使用场景

    千次阅读 2019-10-24 22:54:08
    文章目录Java线程池四种用法与使用场景一、如下方式存在的问题二、使用线程池有什么优点三、线程池四种使用方式1、newCachedThreadPool2、newFixedThreadPool3、newScheduledThreadPool4、... ...
  • 一、创建一个可缓存的线程池,如果线程池长度超出处理需要, import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * 创建一个可缓存的线程池,如果线程池长度超出处理需要...
  • 线程池创建问题

    2019-11-18 14:47:27
    从这个函数来看,其实是分是否需要默认的线程池工厂和handler。接下来就讲讲这些参数代表什么。 corePoolSize:核心线程数量。当线程数少于corePoolSize的时候,直接创建新的线程,尽管其他线程是空闲的。当线程池...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 101,277
精华内容 40,510
关键字:

线程池创建的四种