多线程的多种方式

第一种方式：

package Thread;

//第一种方式：继承Thread
public class TheThread {

    public static void main(String[] args) {



        TaskThread task1 = new TaskThread();
        TaskThread task2 = new TaskThread();

        task1.start();
        task2.start();
        System.out.println("main线程在运行！");
    }

}

class TaskThread extends Thread{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getId()+"线程正在运行！");
    }
}

　　

第二种方式：

package Thread;

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

        TaskRunnable task1 = new TaskRunnable();
        TaskRunnable task2 = new TaskRunnable();
        new Thread(task1).start();
        new Thread(task2).start();
    }

}


class TaskRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getId()+"线程正在运行！");
    }
}

　　

第三种方式：

package Thread;

//用lamada表达式执行
public class TheLamda {

    public static void main(String[] args) {
        new Thread(()->{
            System.out.println(Thread.currentThread().getId()+"正在运行中");
        }).start();

        new Thread(()->{
            System.out.println(Thread.currentThread().getId()+"正在运行中");
        }).start();
    }

}

　　

第四种方式：

package Thread;

import java.util.concurrent.*;

//用callable接口实现
public class TheCallable {
    public static void main(String[] args) throws Exception {

        ExecutorService executorService = Executors.newCachedThreadPool();

        TaskCallable taskCallable = new TaskCallable("小明");
        Future<String> future = executorService.submit(taskCallable);
        try {
            System.out.println("这里是为了测试一下程序的执行。");
            System.out.println("调用call()方法返回的结果：" + future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}


 class TaskCallable implements Callable{
    String name;
    public TaskCallable(String name){
        this.name=name;
    }

    @Override
    public String call() throws Exception {
        return "这是callable线程"+this.name;
    }
}

　　

第五种方式：

package Thread;

import java.util.concurrent.*;

//自定义线程池
public class TheThreadPool {
    public static void main(String[] args) {
        //1.自定义一个线程池
        ExecutorService executorService = new ThreadPoolExecutor(
                2,   //核心线程数   当线程超过2，就会把超过的线程放到阻塞队列中，进行等待
                5, //最大线程数   当这个最先线程数也满了就会触发拒绝策略
                2l,   //线程的存活时间
                TimeUnit.SECONDS,   //时间单位
                new ArrayBlockingQueue<>(3), //阻塞队列    当阻塞队列满了，就会去“最大线程数”开辟新的线程优先处理
                Executors.defaultThreadFactory(),    //线程工厂
                new ThreadPoolExecutor.AbortPolicy()  //拒绝策略
        );

        TaskCallable taskCallable = new TaskCallable("小明");
        Future<String> future = executorService.submit(taskCallable);
        try {
            System.out.println("这里是为了测试一下程序的执行。");
            System.out.println("调用call()方法返回的结果：" + future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }



    }
}

class TaskCallable2 implements Callable{
    String name;
    public TaskCallable2(String name){
        this.name=name;
    }

    @Override
    public String call() throws Exception {
        return "这是callable线程"+this.name;
    }
}