创建多线程的四种方式 |
您所在的位置：网站首页 › 线程的四种实现方式 › 创建多线程的四种方式 |
创建多线程的四种方式
|
目录儿
一、创建线程的四种方式1. 继承Thread类2. 实现Runnable接口3. 实现Callable接口4. 线程池禁止使用 Executors 构建线程池构建线程池的正确方式
一、创建线程的四种方式
1. 继承Thread类
① 创建一个类继承Thread类，重写run()方法 ② 调用start()方法启动线程 例： /* 创建三个窗口卖票，总票数为100 */ public class TicketWindow extends Thread { //线程共享资源（100张票） private static int ticket = 100; //同步锁必须是唯一的 private static final Object obj = new Object(); @Override public void run() { while(true){ synchronized(obj){ if(ticket > 0){ //暂停当前线程，允许其它具有相同优先级的线程获得运行机会 Thread.yield(); System.out.println(getName() + "卖票： 票号：" + ticket); ticket--; }else { break; } } } } public static void main(String[] args) { TicketWindow w1 = new TicketWindow(); w1.setName("一号窗口"); w1.start(); TicketWindow w2 = new TicketWindow(); w2.setName("二号窗口"); w2.start(); Thread w3 = new TicketWindow(); //TicketWindow继承了Thread，可以用Thread接收TicketWindow对象 w3.setName("三号窗口"); w3.start(); } } 2. 实现Runnable接口① 创建类实现Runnable接口，重写run()方法 ② 以实现类作为构造器参数，创建一个线程（Thread）对象 ③ 调用start()方法启动线程 例 /* 创建三个窗口卖票，总票数为100 */ public class TicketWindow implements Runnable { //线程共享资源（100张票） private static int ticket = 100; //同步锁必须是唯一的 private static final Object obj = new Object(); @Override public void run() { while(true){ synchronized(obj){ if(ticket > 0){ //暂停当前线程，允许其它具有相同优先级的线程执行(不能保证运行顺序) Thread.yield(); System.out.println(Thread.currentThread().getName() + "卖票： 票号：" + ticket); ticket--; }else { break; } } } } public static void main(String[] args) { TicketWindow ticketWindow = new TicketWindow(); new Thread(ticketWindow, "一号窗口").start(); new Thread(ticketWindow, "二号窗口").start(); new Thread(ticketWindow, "三号窗口").start(); } }注意：实现Runnable接口方式中，调用的不是Thread类的run()方法，而是在线程启动后，去调用Runnable类型的run()方法，也就是我们传入的实现类中的run()方法 3. 实现Callable接口① 创建类实现Callable接口，重写call()方法 ② 创建实现类对象 ③ 将实现类对象作为构造器参数，创建FutureTask对象 ④ FutureTask对象作为构造器参数，创建Thread对象 ⑤ 调用Thread对象的start()方法启动线程 ⑥ 调用FutureTask对象的get()方法获取返回值 例： // 1. 创建一个类来实现Callable接口 public class TicketWindow implements Callable { //线程共享资源（100张票） private static int ticket = 100; //同步锁必须是唯一的 private static final Object obj = new Object(); // 2. 重写call()方法，返回值类型可以根据需求指定，但必须与创建FutureTask对象时里面的泛型一致 @Override public Object call() { while(true){ synchronized(obj){ if(ticket > 0){ //暂停当前线程，允许其它具有相同优先级的线程获得运行机会 Thread.yield(); System.out.println(Thread.currentThread().getName() + "卖票： 票号：" + ticket); ticket--; }else { break; } } } return Thread.currentThread().getName() + "执行完毕 ~ ~"; } public static void main(String[] args) throws ExecutionException, InterruptedException { // 3. 创建Callable接口实现类的对象 TicketWindow ticketWindow = new TicketWindow(); // 4. 将实现类对象作为参数传到FutureTask类的构造器中，创建FutureTask类的对象 FutureTask futureTask1 = new FutureTask(ticketWindow); // 5. 将FutureTask类对象传到Thread类的构造器中，创建线程对象（因为FutureTask实现了Runnable接口，所以可以这样传） Thread t1 = new Thread(futureTask1, "1号窗口"); // 6. 通过线程对象调用start()方法开启线程 t1.start(); FutureTask futureTask2 = new FutureTask(ticketWindow); Thread t2 = new Thread(futureTask2, "2号窗口"); t2.start(); FutureTask futureTask3 = new FutureTask(ticketWindow); Thread t3 = new Thread(futureTask3, "3号窗口"); t3.start(); // 8. 调用FutureTask类的get()方法获取call()方法的返回值，如果不需要返回值可以省略这一步 Object result1= futureTask1.get(); Object result2= futureTask2.get(); Object result3= futureTask3.get(); System.out.println(result); } } 4. 线程池使用线程池创建线程，是实际项目开发中最常用的方式，它拥有许多好处： 提高响应速度 (因为减少了创建新线程的时间)降低资源损耗 (重复利用线程池中的线程，不需要每次都创建和销毁)便于线程的管理 import java.util.concurrent.*; /* 水果售卖窗口 */ class FruitWindow implements Runnable { private int fruitNumber = 100; @Override public void run() { while (true) { /* 1.任何一个类的对象，都可以充当锁，一般使用Object类对象 */ /* 2.多个线程必须共用一把锁，多个线程抢一把锁，谁抢到谁执行 */ synchronized (this) { if (fruitNumber > 0) { try { //休眠30毫秒 TimeUnit.MILLISECONDS.sleep(30); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "卖第：" + fruitNumber + "份水果"); fruitNumber--; } else { break; } } } } } /* 蔬菜售卖窗口 */ class VegetableWindow implements Callable { private int vegetableNumber = 100; @Override public Object call() { while (true) { /* 1.任何一个类的对象，都可以充当锁，一般使用Object类对象 */ /* 2.多个线程必须共用一把锁，多个线程抢一把锁，谁抢到谁执行 */ synchronized (this) { if (vegetableNumber > 0) { try { //休眠20毫秒 TimeUnit.MILLISECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "卖第：" + vegetableNumber + "份蔬菜"); vegetableNumber--; } else { break; } } } return null; } } public class ThreadPool { public static void main(String[] args) { // 1.提供指定线程数量的线程池 ExecutorService pool= Executors.newFixedThreadPool(10); // 设置线程池的属性 (线程管理) ThreadPoolExecutor poolconfig = (ThreadPoolExecutor) pool; //设置属性前，需要将接口类型 强转为 实现类类型 poolconfig .setCorePoolSize(10); //核心池的大小（最小线程数） poolconfig .setMaximumPoolSize(15); //最大线程数 //参数1：时间值。时间值为零将导致多余的线程在执行任务后立即终止 //参数2：时间单位，使用TimeUnit类指定，TimeUnit.DAYS为天、TimeUnit.HOURS为小时、TimeUnit.MINUTES为分钟、TimeUnit.SECONDS为秒，TimeUnit.MICROSECONDS为微秒 poolconfig .setKeepAliveTime(5, TimeUnit.MINUTES); //空闲线程存活时间 // . . . // 2.执行指定的线程操作 （需要提供实现了Runnable接口 或 Callable接口实现类的对象 ） FruitWindow fruitWindow = new FruitWindow(); /* 注意：操作共享数据的线程必须共用同一把锁 */ pool.execute(fruitWindow); //适用于Runnable pool.execute(fruitWindow); //适用于Runnable pool.execute(fruitWindow); //适用于Runnable VegetableWindow vegetableWindow = new VegetableWindow(); /* 注意：操作共享数据的线程必须共用同一把锁 */ pool.submit(vegetableWindow); //适用于Callable pool.submit(vegetableWindow); //适用于Callable Future future = pool.submit(vegetableWindow); //适用于Callable // 获取call()方法的返回值 Object result = future.get(); System.out.println(result); pool.shutdown(); //关闭连接池 } } 禁止使用 Executors 构建线程池上面的例子用到了Executors静态工厂构建线程池，但一般不建议这样使用 Executors是一个Java中的工具类。提供工厂方法来创建不同类型的线程池。 原因： Executors的静态方法创建线程池时，用的是 LinkedBlockingQueue阻塞队列，如创建固定线程池的方法newFixedThreadPool()： public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue()); }Java 中的 BlockingQueue 主要有两种实现，分别是 : ArrayBlockingQueueLinkedBlockingQueue。ArrayBlockingQueue 是一个用数组实现的有界阻塞队列，必须设置容量。 LinkedBlockingQueue 是一个用链表实现的有界阻塞队列，在不设置的情况下，将是一个无边界的阻塞队列，最大长度为 Integer.MAX_VALUE。 这里的问题就出在这里，newFixedThreadPool 中创建 LinkedBlockingQueue 时，并未指定容量。此时，LinkedBlockingQueue 就是一个无边界队列，对于一个无边界队列来说，是可以不断的向队列中加入任务的，这种情况下就有可能因为任务过多而导致内存溢出问题。 上面提到的问题主要体现在 newFixedThreadPool 和 newSingleThreadExecutor 两个工厂方法上 而 newCachedThreadPool 和newScheduledThreadPool 这两个方法虽然没有用LinkedBlockingQueue阻塞队列，但是它默认的最大线程数是Integer.MAX_VALUE，也会有导致OOM的风险。 // 缓存线程池 public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue()); } // 周期线程池 public ScheduledThreadPoolExecutor(int corePoolSize) { super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,new DelayedWorkQueue()); } 构建线程池的正确方式避免使用 Executors 创建线程池，主要是避免使用其中的默认实现，那么我们可以自己直接调用 ThreadPoolExecutor 的构造函数来自己创建线程池。在创建的同时，给 BlockQueue 指定容量就可以了： private static ExecutorService executor = new ThreadPoolExecutor( 10, 10, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue(10) );还要指定拒绝策略，处理好任务队列溢出时的异常问题。 参考资料： CSDN CD4356 Java 多线程详解（二）：创建线程的4种方式 https://blog.csdn.net/weixin_42950079/article/details/124862582Java开发手册 http://static.kancloud.cn/mtdev/java-manual/content/%E4%B8%BA%E4%BB%80%E4%B9%88%E7%A6%81%E6%AD%A2%E4%BD%BF%E7%94%A8Executors%E5%88%9B%E5%BB%BA%E7%BA%BF%E7%A8%8B%E6%B1%A0%EF%BC%9F.md |
虽然它很大程度的简化的创建线程池的过程，但是它有一个致命缺陷：在Java开发手册中提到，使用Executors创建线程池可能会导致OOM(Out-OfMemory , 内存溢出 )【本文地址】