线程---三种创建方式实例；以及线程池的使用

1、继承Thread类

• 继承Thread类，重写run方法（即要让线程进行的操作），

• 创建线程实例，调用start()方法启动线程。

import java.util.Date;

/**
 * @author: ycz
 * @date: 2018/11/25 0025 15:48
 * @description: 继承Thread方法
 */
public class MyThread extends Thread {
    private final static int COUNT=100;
    private String name;

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

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

    public static void main(String[] args) {
        MyThread p1 = new MyThread("zero");
        MyThread p2 = new MyThread("one");
        p1.start();
        p2.start();

    }
}

 

2、实现runable接口

• 实现runable接口，重写run方法；

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

import java.util.Date;

/**
 * @author: ycz
 * @date: 2018/11/25 0025 16:02
 * @description: 实现runable方法
 */
public class MyThread2 implements Runnable {
    private final static int COUNT=100;
    private String name;

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

    @Override
    public void run() {
        for (int i=0;i<COUNT;i++) {
            System.out.println(Thread.currentThread().getName()+"--"+name+"---"+ new Date());
        }
    }
    public static void main(String[] args) {
        Runnable runnable = new MyThread2("zero");
        Thread p1 = new Thread(runnable);
        p1.start();
        Runnable runnable2 = new MyThread2("one");
        Thread p2 = new Thread(runnable2);
        p2.start();
    }
}

 

 

 

3、实现callable接口

• 实现callable接口重写call()方法，该方法为线程进行的操作，并且具有返回值；

• 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

•  使用FutureTask对象作为Thread对象的target创建并启动新线程。

• 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值其中： 

 

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

/**
 * @author: ycz
 * @date: 2018/11/25 0025 16:17
 * @description:
 */
public class MyThread3 implements Callable {
    private final static int COUNT=100;
    private String name;
    public MyThread3(String name) {
        this.name = name;
    }

    /**
     * 重写call()方法；返回1~100的和
     * @return
     * @throws Exception
     */
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i=0;i<COUNT;i++) {
                System.out.println(Thread.currentThread().getName()+"--"+name+"---"+ new Date());
                sum += i;
        }
        return sum;
    }

    public static void main(String[] args) {
        //创建callable()实例化对象
        MyThread3 p1 = new MyThread3("zero");
        //使用FutureTask类来包装Callable对象
        FutureTask<Integer> futureTask = new FutureTask<Integer>(p1);
        //使用FutureTask对象作为Thread对象的target创建并启动新线程
        new Thread(futureTask).start();
        Integer sum;
        MyThread3 p2 = new MyThread3("one");
        FutureTask<Integer> futureTask1 = new FutureTask<Integer>(p2);
        new Thread(futureTask1).start();
        Integer sum1;
        try {
            //等所有线程执行完，获取值，因此FutureTask 可用于 闭锁
            sum = futureTask.get();
            System.out.println("sum:"+sum);
            sum1 = futureTask1.get();
            System.out.println("sum1:"+sum1);
        }catch (Exception e ){
            e.printStackTrace();
        }
    }
}

参考：https://www.cnblogs.com/snow-flower/p/6114765.html