多线程代码 java 多线程代码怎么写

1、编写线程类

1. 继承Thread类，重写run方法
2. 实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target
3. 通过Callable和FutureTask创建线程（线程有返回值）
4. 通过线程池创建线程

前面两种可以归为一类：无返回值，原因很简单，通过重写run方法，run方式的返回值是void，所以没有办法返回结果。

后面两种可以归结成一类：有返回值，通过Callable接口，就要实现call方法，这个方法的返回值是Object，所以返回的结果可以放在Object对象中。

2、继承Thread类，重写该类的run() 方法

在Thread子类中的run方法编写线程类要实现的功能代码

public class TD1 {
    public static void main(String[] args) {
        // 测试代码
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30){
                Thread myThread1 = new Thread(); // 创建一个新的线程 myThread1 此线程进入新建状态
                Thread myThread2 = new Thread(); // 创建一个新的线程 myThread2 此线程进入新建状态
                myThread1.start(); // 调用start()方法使得线程进入就绪状态
                myThread2.start(); // 调用start()方法使得线程进入就绪状态
            }
        }
    }
}

// 编写线程类
    class MyThread extends Thread{
    private int i = 0;

    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}

实现效果：

如上所示，继承Thread类，通过重写run()方法定义了一个新的线程类MyThread，其中run()方法的方法体代表了县城需要完成的任务，称之为线程执行体。当创建此线程类对象时一个新的线程得以创建，并进入到线程新建状态。通过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不一定会马上得以执行，这取决于CPU调度时机。

3、实现Runnable接口，重写run方法

创建Runnable实现类的实例，并以此实例组偶为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。

public class TD2 {
    public static void TDemo(String[] args) {
        // lambda表达式
        Runnable myt = () -> {
            System.out.println(Thread.currentThread().getName());
        };

        for (int i = 0; i < 5; i++) {
            new Thread(myt,"T" + i).start();
        }
    }


    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30){
                Runnable myRunnable = new Thread1(); // 创建一个Runnable实现类的对象
                Thread t1 = new Thread(myRunnable); // 将myRunnable作为Threadtarget创建新的线程
                Thread t2 = new Thread(myRunnable);
                t1.start(); // 调用start()方法使得线程进入就绪状态
                t2.start();
            }
        }
    }

}

    class Thread1 implements Runnable {
        private int i = 0;

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
        }
    }

实现效果：

4、Callable和Future接口创建线程

(a)：创建Callable接口的实现类，并实现Call方法(b)：创建Callable实现类的实现，使用FutureTask类包装Callable对象，该FutureTask对象封装了Callable对象的Call方法的返回值(c)：使用FutureTask对象作为Thread对象的target创建去启动线程(d)：调用FutureTask对象的get()来获取子线程执行结束的返回值

public class TD3 {
    public static void main(String[] args) {
        Callable<Integer> myCallable = new MyCallable(); // 创建MyCallable对象
        FutureTask<Integer> ft = new FutureTask<>(myCallable); // 使用FutureTask来包装MyCallable对象
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30){
                Thread thread = new Thread(ft); // FutureTask对象作为Thread对象的target创建新的线程
                thread.start(); // 线程进入到就绪状态
            }
        }
        System.out.println("主线程for循环执行完毕..");
        try {
            int sum = ft.get(); // 取得新创建的新线程中的call()方法返回的结果
            System.out.println("sum = " + sum);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

class MyCallable implements Callable<Integer> {
    private int i = 0;
    // 与run()方法不同的是，call()方法具有返回值

    @Override
    public Integer call(){
        int sum = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return  sum;
    }
}

首先，我们发现，在实现Callable接口中，此时不再是run()方法了，而是call()方法作为线程执行体，同时还具有返回值！在创建新的线程时，时通过FutureTask来包装MyCallable对象，同时作为了Thread对象的target。

实现效果：

5、通过线程池创建线程

public class TD4 {
    private static int POOL_NUM = 10; // 线程池数量
    public static void main(String[] args) throws InterruptedException{
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < POOL_NUM; i++) {
            RunnableThread thread = new RunnableThread();
            // Thread.sleep(1000);
            executorService.execute(thread);
        }
        // 关闭线程池
        executorService.shutdown();
    }
}

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

实现效果：

ExecutorService、Callable都是属于Executor框架。返回结果的线程是在JDK1.5中引入的新特性，还有Future接口也是属于这个框架，有了这种特征得到返回值就很方便了。通过分析可以知道，他同样也是实现了Callable接口，实现了Call方法，所以有返回值。这也就是正好符合了前面所说的两种分类。

执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了。get方法是阻塞的，即：线程无返回结果，get方法会一直等待。

再介绍Executors类：提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。

public static ExcutorService new FixedThreadPool(int nThreads) 创建固定数目线程的线程池。

public static ExecutorService newCachedThreadPool() 创建一个可缓存的线程池，调用execute将重用以前构造的线程（如果县城可用）。如果现有现成没有可用的，则创建一个新线程并添加到池中，终止并从缓存中移除那些已有60秒钟未被使用的线程。

public static ExecutorService newSingleThreadExecutor() 创建一个单线程化的Executor.

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 创建一个支持定时及周期性的任务执行的线程池，多数去情况下可用来替代Timer类。

ExecutorService提供了submit()方法，传递一个Callable，或Runnable，返回Future。结果Executor后台县城还没有完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成。