java多线程如何同时跑

转载

footballboy 2024-10-29 11:12:05

文章标签 java多线程如何同时跑线程池 System ide 文章分类 Java 后端开发

（1）继承Thread类，重写run方法
（2）实现Runnable接口，重写run方法，将Runnable接口的实现类的实例对象作为Thread构造函数参数
（3）通过Callable和FutureTask创建线程
（4）通过线程池创建线程。线程池提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度

（1）继承Thread类，重写run方法

public class TestThread extends Thread{
    public TestThread(){
        //编写子类的构造方法，可缺省
    }
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName());
    }
    public static void main(String[] args){
        TestThread thread1 = new TestThread();
        thread1.start();
        System.out.println(Thread.currentThread().toString());
    }
}

运行结果：

Thread[main,5,main]
Thread-0

（2）实现Runnable接口，重写run方法，将Runnable接口的实现类的实例对象作为Thread构造函数参数

public class TestThread2 {
    public static void main(String[] args){
        System.out.println(Thread.currentThread().getName());
        Thread t1 = new Thread(new MyThread());
        t1.start();
    }

}


class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

运行结果：

main
Thread-0

（3）通过Callable和FutureTask创建线程
创建Callable接口的实现类，并实现Call方法
创建Callable实现类的实例，使用FutureTask类包装Callable对象，该FutureTask对象封装了Callable对象的Call方法的返回值
使用FutureTask对象作为Thread对象的target创建并启动线程
调用FutureTask对象的get()来获取子线程执行结束的返回值

public class TestThread3 {
    public static void main(String[] args) {

        Callable<Object> oneCallable = new Tickets<Object>();
        FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);

        Thread t = new Thread(oneTask);

        System.out.println(Thread.currentThread().getName());

        t.start();

    }

}


class Tickets<Object> implements Callable<Object> {

    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName() + "-->我是通过实现Callable接口通过FutureTask包装器来实现的线程");
        return null;
    }
}

运行结果：

main
Thread-0-->我是通过实现Callable接口通过FutureTask包装器来实现的线程

（4）通过线程池创建线程

public class TestThread4 {

    //线程池数量
    private static int POOL_NUM = 10;


    public static void main(String[] args) throws InterruptedException {

        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                5,10,10, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(1),
                new ThreadPoolExecutor.DiscardOldestPolicy());

        for(int i = 0; i<POOL_NUM; i++){
            RunnableThread thread = new RunnableThread();

            //Thread.sleep(1000);
            threadPool.execute(thread);
        }
        //关闭线程池
        threadPool.shutdown();

    }

}

class RunnableThread implements Runnable {
    @Override
    public void run() {
        System.out.println("通过线程池方式创建的线程：" + Thread.currentThread().getName() + " ");
    }
}

运行结果：

通过线程池方式创建的线程：pool-1-thread-1 
通过线程池方式创建的线程：pool-1-thread-2 
通过线程池方式创建的线程：pool-1-thread-1 
通过线程池方式创建的线程：pool-1-thread-3 
通过线程池方式创建的线程：pool-1-thread-4 
通过线程池方式创建的线程：pool-1-thread-5 
通过线程池方式创建的线程：pool-1-thread-6 
通过线程池方式创建的线程：pool-1-thread-7 
通过线程池方式创建的线程：pool-1-thread-8 
通过线程池方式创建的线程：pool-1-thread-9

线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

ThreadPoolExecutor 构造器如下

public ThreadPoolExecutor(
            int corePoolSize, //线程池核心池的大小。
            int maximumPoolSize, // 线程池的最大线程数。
            long keepAliveTime, // 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
            TimeUnit unit, // keepAliveTime 的时间单位。
            BlockingQueue<Runnable> workQueue, // 用来储存等待执行任务的队列。
            ThreadFactory threadFactory, // 线程工厂
            RejectedExecutionHandler handler)  // 拒绝策略
    )