utils012_创建线程的三种方法简单介绍

package com.jingsong.test;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;

/**
 * @author jingsong
 * @date 2022/5/4 14:49
 * @desc 多线程基础学习
 */
public class ThreadsTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
            1. 基本概念
                a. 并发和并行
                    并行：在同一时刻，有多个指令在多个cpu上同时执行
                    并发：在同一时刻，有多个指令在单个cpu上交替执行
         */

        /*
            2. 方法说明
                1. run()：用户自定义线程如何执行的方法，直接执行该方法相当于普通方法
                2. start()：启动这条线程，然后由jvm(cpu)决定啥时候执行我们自定义的run();
         */

        /*
            3. 三种方式（如下面的3个类MyThread，MyRunnable，MyCallable）
                a. 继承Thread
                b. 实现Runnable
                c. 实现Callable
         */

        /*
            3.1 继承Thread，重写了Thread类的run()方法。
                优点：继承了Thread类的衣钵，可以使用其中的方法
                缺点：java单继承导致灵活度受限
         */
        /*MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        myThread1.start();
        myThread2.start();*/

        /*
            3.2 实现Runnable，较多使用
                Thread类中的run()方法重写自Runnable接口中的run方法。
                当我们传入了自定义Runnable方法时，Thread类会将其为target字段赋值，并执行
         */

        /*MyRunnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);
        thread1.start();
        thread2.start();*/

        /*
            3.3 实现Callable接口，编程复杂，但是可以获得返回值
                FutureTask类同样实现了Runnable接口，多线程执行也是其中的run方法，只是在run方法中工作为执行call方法
                注意：需要new 两个FutureTask对象才能使两个线程都执行（毕竟每个线程都需要获得返回值）
         */
        /*MyCallable myCallable = new MyCallable();
        FutureTask<String> futureTask1 = new FutureTask<>(myCallable);
        FutureTask<String> futureTask2 = new FutureTask<>(myCallable);
        Thread thread1 = new Thread(futureTask1);
        Thread thread2 = new Thread(futureTask2);
        thread1.start();
        thread2.start();
        System.out.println("hehe");
        System.out.println(futureTask1.get());
        System.out.println(futureTask2.get());*/

        /*
            4. lambda写法

         */
        /*Thread thread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + i);
            }
        });
        thread.start();*/

        /*FutureTask<String> task = new FutureTask<>(() -> "haha");
        Thread thread1 = new Thread(task);
        thread1.start();
        System.out.println(task.get());*/

        /*
            5. 守护线程 没用过
                官方解释：当 JVM 中不存在任何一个正在运行的非守护线程时，则 JVM 进程即会退出。
                参考：http://t.csdn.cn/yu5Wd
         */
        //new Thread().setDaemon(true);

        /*
            6. 线程优先级 1-10 (10的优先级最高)
                仅仅是抢到执行权的概率问题，并不绝对
         */
        new Thread().setPriority(10);
    }
}

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

class MyRunnable implements Runnable {

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

class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName() +"aa");
        Thread.sleep(5000L);
        System.out.println(Thread.currentThread().getName() +"bb");
        return new SimpleDateFormat("yyyy MM dd-HH:mm:ss:SSS").format(new Date());
    }
}