java中创建线程的几种方式

1.通过实现Runnable接口创建线程

package com.mystudy.test;

/**
 * Author:dk
 * Date:2020/7/27 15:57
 * Description:
 */
public class TestRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程中需要执行的代码块···");
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new TestRunnable());
        thread.start();
    }
}

2.通过继承Thread类创建线程

package com.mystudy.test;

/**
 * Author:dk
 * Date:2020/7/27 16:04
 * Description:
 */
public class TestThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程中需要执行的代码块···");
    }

    public static void main(String[] args) {
        Thread th = new TestThread();
        th.start();
    }
}

3.通过实现callable接口创建线程

package com.mystudy.test;

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

/**
 * Author:dk
 * Date:2020/7/27 16:08
 * Description:
 */
public class TestCallable implements Callable {
    @Override
    public Object call() throws Exception {
        System.out.println("线程中需要执行的代码块···");
        return "success";
    }

    public static void main(String[] args) {
        Callable call = new TestCallable();
        FutureTask future = new FutureTask(call);
        future.run();
    }
}

4.使用Executor框架来创建线程池

package com.mystudy.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * Author:dk
 * Date:2020/7/27 16:16
 * Description:
 */
public class TestThreadPoolExecutor {
    public static void main(String[] args) {
        //创建使用单个线程的线程池
        ExecutorService es1 = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            es1.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "正在执行任务");
                }
            });
        }
        //创建使用固定线程数的线程池
        ExecutorService es2 = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            es2.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "正在执行任务");
                }
            });
        }
        //创建一个会根据需要创建新线程的线程池
        ExecutorService es3 = Executors.newCachedThreadPool();
        for (int i = 0; i < 20; i++) {
            es3.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "正在执行任务");
                }
            });
        }
        //创建拥有固定线程数量的定时线程任务的线程池
        ScheduledExecutorService es4 = Executors.newScheduledThreadPool(2);
        System.out.println("时间：" + System.currentTimeMillis());
        for (int i = 0; i < 5; i++) {
            es4.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("时间：" + System.currentTimeMillis() + "--" + Thread.currentThread().getName() + "正在执行任务");
                }
            }, 3, TimeUnit.SECONDS);
        }
        //创建只有一个线程的定时线程任务的线程池
        ScheduledExecutorService es5 = Executors.newSingleThreadScheduledExecutor();
        System.out.println("时间：" + System.currentTimeMillis());
        for (int i = 0; i < 5; i++) {
            es5.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("时间：" + System.currentTimeMillis() + "--" + Thread.currentThread().getName() + "正在执行任务");
                }
            }, 3, TimeUnit.SECONDS);
        }
    }
}

5.通过匿名内部类创建多线程

package com.mystudy.test;

/**
 * Author:dk
 * Date:2020/7/27 16:20
 * Description:
 */
public class ThreadTest {
    public static void main(String[] args) {
        /*
         * 第一种方式：
         * 1.继承Thread类
         * 2.重写run方法
         * 3.将要执行的代码写在run方法中
         */
        new Thread() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("aaaaaaaaa");
                }
            }
        }.start();//开启线程
        
        /*
         * 第二种方式：
         * 1.将Runnable的子类对象传递给Thread的构造方法
         * 2.重写run方法
         * 3.将执行的代码写在run方法中，最后我们开启线程
         */
        new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("bbbbbbbbb");
                }
            }
        }).start();//开启线程
    }
}