Java创建多线的方式

方式一：继承Thread类

① 定义继承Thread类的子类；
② 重写run()方法，run()方法的主体即为线程体
③ 实例化继承Thread的子类的对象，即创建线程对象；
④ 通过实例对象调用start()方法启动线程
　　注意：想要启动多线程必须调用start()方法，通过start()方法调用run()方法，若手动调用run()方法，则不会启动多线程。
　　　　　　因为run()方法必须由JVM调用，至于什么时候调用，执行过程的控制都有操作系统的调度决定。

package com.exercise.mulTreadTest;
//方式1： 通过继承Thread类的方式实现多线程：

/**
 * ① 定义继承Thread类的子类；
 * ② 重写run()方法，run()方法的主体即为线程体
 * ③ 实例化继承Thread的子类的对象，即创建线程对象；
 * ④ 通过实例对象调用start()方法启动线程
 */
public class extendsThread {
    public static void main(String[] args) {
        myThread1 thread1 = new myThread1();
        thread1.start();

        myThread1 thread2 = new myThread1();
        thread2.start();
    }
}

class myThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + " : " + i);
            }
        }
    }
}

上述代码创建多线程的运行结果如下：可见线程1和线程2交替执行。

 

 

 

方式二：实现Runnable接口

 ① 创建一个实现Runnable接口的子类myThread；
 ② 重写Runnable接口中的run()方法；
 ③ 创建该子类myThread的对象；
 ④ 创建Thread类的对象，并且将子类myThread创建的对象作为Thread类含参构造器的实参
 ⑤ 调用start()方法启动线程

package com.exercise.mulTreadTest;

/**
 * 方式二：实现Runnable接口
 * ① 创建一个实现Runnable接口的子类myThread；
 * ② 重写Runnable接口中的run()方法；
 * ③ 创建该子类myThread的对象；
 * ④ 创建Thread类的对象，并且将子类myThread创建的对象作为Thread类含参构造器的实参
 * ⑤ 调用start()方法启动线程
 *
 */
public class implRunnable{
    public static void main(String[] args) {
        myThread2 myThread2 = new myThread2();
        Thread thread1 = new Thread(myThread2);
        Thread thread2 = new Thread(myThread2);
        thread1.start();
        thread2.start();
    }

}

class myThread2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + " : " + i);
            }
        }
    }
}

继承Thread类和实现Runnable接口创建多线程方式的区别：
区别：
　　①继承Thread类的方式重写了Thread类的run()方法并将线程代码放在里面；
　　②实现Runnable接口的方式重写了Runnable接口中的run()方法，线程代码存在其中。

实现Runnable接口创建多线的好处:
　　①避免单继承性的局限性：接口的好处
　　②多个接口共享同一个接口实现类的对象，非常适合多个相同线程处理同一份资源。

方式三： 实现Callable接口
①创建一个实现Callable接口的实现类；
②在实现类中重写call()方法，即线程体；
③创建实现类的实例；
④使用实现类的实例作为参数创建一个FutureTask类的实例；
⑤使用FutrueTask类的实例作为参数创建一个Thread类的实例并调用start()方法启动线程；
⑥使用FutureTask实例调用get()方法获取call()方法的返回值。

package com.exercise.mulTreadTest;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class implCallable {
    public static void main(String[] args) {
        //3.创建实现类myThread3的实例
        myThread3 myThread3 = new myThread3();
        //4.使用myThread3作为参数创建FutureTask类的实例
        FutureTask futureTask = new FutureTask(myThread3);
        //5.使用futureTask作为参数创建Thread类的实例
        Thread thread = new Thread(futureTask);
        //6.启动线程
        thread.start();

        try {
            //7.获取call()方法的返回值
            Object o = futureTask.get();
            System.out.println(o);

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

//1.创建接口Callable的实现类
class myThread3 implements Callable {
    //重写call()方法
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}

 方式四： 使用线程池

package com.exercise.java2;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 创建线程的方式四:使用线程池
 * 好处:
 *  1.提高响应速度(减少创建线程的时间);
 *  2.降低资源消耗(重复利用线程池中的线程,不需要每次都创建)
 *  3.便于线程管理
 *      √ corePoolSize: 核心池的大小
 *      √ maximumPoolSize: 最大线程数
 *      √ keepAliveTime: 线程没有任务是最多保持多长时间后会终止
 */

class NumberThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100 ; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100 ; i++) {
            if(i % 2 == 1){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        ThreadPoolExecutor service1 = (ThreadPoolExecutor)executorService;

        service1.setCorePoolSize(15);;
        //设置线程池的属性
        System.out.println(executorService.getClass());

        //2.执行指定的线程操作.需要实现Runnable接口或Callable接口类的对象
        executorService.execute(new NumberThread());   //适合适用于Runnable
        executorService.execute(new NumberThread1());


//        executorService.submit(Callable callable);    //适合使用于Callable
        //3.关闭线程池
        executorService.shutdown();
    }
}