Java中创建线程的四种方法解析

package com.scg.springcloudordercenter.controller;
 
// 1.继承Thread类
public class ThreadDemo extends Thread{
 
    private int ticket=20;
 
    // 2.重写run 方法
    public void run(){
        for(int i=0;i<20;i++){
 
            if(this.ticket>0){
                System.out.println("剩余票数=="+ticket--);
            }
        }
 
    }
}
 
class ThreadTest {
    public static void main(String[] args) {
        // 3.实例化线程对象
        ThreadDemo md = new ThreadDemo() ;
        // 4.调用start()开启线程
        md.start();
    }
}
 
 

package com.scg.springcloudordercenter.controller;
 
 
// 1.实现Runnable类
public class RunnableDemo implements Runnable{
 
    private int ticket=20;
 
    // 2.重写run 方法
    public void run(){
        for(int i=0;i<20;i++){
 
            if(this.ticket>0){
                System.out.println("剩余票数=="+ticket--);
            }
        }
 
    }
}
 
class RunnableTest {
    public static void main(String[] args) {
        // 3.实例化实现类
        RunnableDemo rd = new RunnableDemo() ;
        // 4.将实例化实现类转化为线程对象
        Thread thread = new Thread(rd);
        // 5.开启线程
        thread.start();
    }
}
 
 

/**
 * @author gf
 * @date 2023/2/22
 */
// 1、定义一个线程任务类实现Callable接口，声明线程执行的结果类型。
public class CallableTicket implements Callable<Object > {
 
    private int ticket=20;
 
    // 2、重写线程任务类的call()方法，这个方法可以直接返回执行的结果。
    @Override
    public Object  call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                sum += i;
            }
        }
        return sum;
    }
 
}

package com.scg.springcloudordercenter.controller;
 
import java.util.concurrent.FutureTask;
 
/**
 * @author gf
 * @date 2023/2/22
 */
public class CallableMain {
 
    public static void main(String[] args) {
 
        // 3、创建一个Callable的线程任务对象。
        CallableTicket callableTicket = new CallableTicket();
 
        // 4、把Callable的线程任务对象包装成一个未来任务对象。
        FutureTask futureTask = new FutureTask(callableTicket);
 
        // 5、把未来任务对象包装成线程对象。
        Thread thread = new Thread(futureTask);
 
        // 6、调用线程start()方法，启动线程。
        thread.start();
 
        // 7、获取线程执行结果。如果此时获取结果的任务还未执行完成，会让出CPU，直至任务执行完成才获取结果。
        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()方法返回值。
            Object sum = futureTask.get();
            System.out.println("总和为："+sum);
        } catch (Exception e) {
            e.printStackTrace();
        }
 
 
    }
}

public class Demo01 {
    public static void main(String[] args) {
        //ExecutorService threadPool = Executors.newSingleThreadExecutor(); //创建单个线程
        //ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(5);//创建一个固定大小的线程池
        //ExecutorService threadPool = Executors.newFixedThreadPool(5); //创建一个固定大小的线程池
        ExecutorService threadPool = Executors.newCachedThreadPool(); //创建大小可伸缩的线程池
 
        try {
            for (int i = 0; i < 30; i++) {
                //使用线程池来创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown(); //线程池使用完毕后需要关闭
        }
 
    }
}

public class Demo02 {
    public static void main(String[] args) {
        //new ThreadPoolExecutor.AbortPolicy():达到最大承载量，不再处理，并且抛出异常
        //new ThreadPoolExecutor.CallerRunsPolicy():达到最大承载量，从哪来的去哪里
        //new ThreadPoolExecutor.DiscardPolicy():达到最大承载量，丢掉任务，但不抛出异常
        //new ThreadPoolExecutor.DiscardOldestPolicy():达到最大承载量，尝试与最早执行的线程去竞争，不抛出异常
 
        //最大线程池大小该如何定义
        //1.cpu密集型，逻辑处理器个数
        //2.io密集型 > 判断程序十分耗IO的线程，最大线程池大小应该比这个大
        int maxPools= Runtime.getRuntime().availableProcessors();
        System.out.println(maxPools);
 
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,
                maxPools,
                3,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy()
        );
 
        try {
            for (int i = 0; i < 10; i++) {
                //使用线程池来创建线程
                //最大承载：maximumPoolSize+workQueue，超过执行拒绝策略
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown(); //线程池使用完毕后需要关闭
        }
 
    }
}