Java多线程4种实现方式

java 多线程学习多线程的作用

发挥多核cpu的优势
防止阻塞

创建多线程的方式 1. implements Runable

public class demo01 {
    
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread("线程A");
        MyThread myThread2 = new MyThread("线程B");
        Thread thread1 = new Thread(myThread1);
        thread1.start();
        Thread thread2 = new Thread(myThread2);
        thread2.start();
    }

    static class MyThread implements Runnable {
        private String name;

        public MyThread(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("hello " + name + "--" + i);
            }
        }
    }
}

实现接口
创建线程实例
创建Thread类，传入线程实例
调用start（）方法

2.extends Thread

public class demo02 {
    public static void main(String[] args) {
        MyThread aaa = new MyThread("aaa");
        MyThread bbb = new MyThread("bbb");
        aaa.start();
        bbb.start();
    }

    
    static class MyThread extends Thread {
        private String name;

        public MyThread(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(name + "---" + i);
            }
        }
    }
}

此时直接创建自定义的线程实例对象，调用start（）方法即可

3. 通过ExecutorService 和 Callable 实现又返回值的线程

public class demo03 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 2.创建固定大小的链接池
        ExecutorService pool = Executors.newFixedThreadPool(5);
        // 3.创建有多个返回值的任务列表
        List list = new ArrayList();
        for (int i = 0; i < 5; i++) {
            // 4. 创建有返回值的线程实例
            Callable c = new MyCallable(i + " ");
            // 5. 提交线程，获得future对象，保存在list中
            Future future = pool.submit(c);
            list.add(future);
        }
        // 6.关闭线程池，等待线程执行结束
        pool.shutdown();
        // 7. 遍历获得返回值
        for (Future future : list) {
            System.out.println(future.get().toString());
        }
    }

    // 1.创建实现了Callable的方法MyCallable
    static class MyCallable implements Callable {
        private String name;

        public MyCallable(String name) {
            this.name = name;
        }

        @Override
        public String call() throws Exception {
            return name;
        }
    }
}

适用于在主线程中开启多个线程并发的执行任务，汇总各个线程的执行结果

4.基于线程池

缓存策略，利用线程池来创建线程
主要作用：

线程的复用------高效
便于线程资源的管理
控制系统的最大并发数------ 安全

public class demo04 {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            threadPool.submit(new Runnable() {

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

Java多线程4种实现方式

Java相关栏目本月热门文章