多线程的基本概念和实现方式，线程的调度，守护线程、礼让线程、插入线程

package com.practice;
/**
 * @Author YJ
 * @Date 2023/7/21 9:41
 * Description:继承Thread类的方式
 */
public class MyThread extends Thread{
    @Override
    public void run() {
        //书写线程要执行的方法
        //getName()获取线程名
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "：hello world");
        }
    }
}

package com.practice;
/**
 * @Author YJ
 * @Date 2023/7/21 9:37
 * Description:继承Thread类的方式
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        //创建对象，启动线程
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        //为线程命名
        thread1.setName("线程1");
        thread2.setName("线程2");
        //开启线程
        thread1.start();
        thread2.start();
    }
}

package com.practice.threaddemo2;
/**
 * @Author YJ
 * @Date 2023/7/21 9:53
 * Description:实现Runnable接口的方式
 */
public class MyRun implements Runnable{
    @Override
    public void run() {
        //获取当前线程的对象
        Thread thread = Thread.currentThread();
        for (int i = 0; i < 100; i++) {
            System.out.println(thread.getName() + "：hello world!");
        }
    }
}

package com.practice.threaddemo2;
/**
 * @Author YJ
 * @Date 2023/7/21 9:53
 * Description:实现Runnable接口的方式
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //创建自己类MyRun的对象
        MyRun myRun = new MyRun();
        //创建线程对象，并传递任务
        Thread thread1 = new Thread(myRun);
        Thread thread2 = new Thread(myRun);
        //给线程命名
        thread1.setName("线程1");
        thread2.setName("线程2");
        //开启线程
        thread1.start();
        thread2.start();
    }
}

package com.practice.threaddemo3;
import java.util.concurrent.Callable;
/**
 * @Author YJ
 * @Date 2023/7/21 10:11
 * Description:利用Callable接口和Future接口方式
 */
public class MyCallable implements Callable<Integer> {
    //求1-100的和
    int sum = 0;
    @Override
    public Integer call() throws Exception {
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}

package com.practice.threaddemo3;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 * @Author YJ
 * @Date 2023/7/21 10:11
 * Description:利用Callable接口和Future接口方式
 */
public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建实现Callable接口的类的对象（表示多线程要执行的任务）
        MyCallable mc = new MyCallable();
        //创建FutureTask的对象（作用管理多线程运行的结果）
        FutureTask<Integer> ft = new FutureTask<>(mc);
        //创建Thread类的对象，并启动线程。
        Thread t1 = new Thread(ft);
        Thread t2 = new Thread(ft);
        //启动线程
        t1.start();
        t2.start();
        //获取结果
        Integer result = ft.get();
        System.out.println(result);
    }
}

package com.practice.threaddemo4;
/**
 * @Author YJ
 * @Date 2023/7/21 10:26
 * Description:构造方法设置名字
 */
public class MyThread extends Thread{
    public MyThread() {
    }
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "@" + i);
        }
    }
}

package com.practice.threaddemo4;
/**
 * @Author YJ
 * @Date 2023/7/21 10:26
 * Description:构造方法设置名字
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //创建线程对象
        MyThread t1 = new MyThread("蓝1");
        MyThread t2 = new MyThread("红2");
        //开启线程
        t1.start();
        t2.start();
    }
}

package com.practice.threaddemo4;
/**
 * @Author YJ
 * @Date 2023/7/21 10:43
 * Description:sleep演示
 */
public class ThreadDemoSleep {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("你好~");
        Thread.sleep(5000);
        System.out.println("hi~");
    }
}

package com.practice.threaddemo5;
/**
 * @Author YJ
 * @Date 2023/7/21 11:04
 * Description:
 */
public class ThreadDemo {
    public static void main(String[] args) {
        MyRun mr = new MyRun();
        Thread t1 = new Thread(mr,"1");
        Thread t2 = new Thread(mr,"2");
        t1.setPriority(1);
        t2.setPriority(10);
        t1.start();
        t2.start();
    }
}

package com.practice.threaddemo6;
/**
 * @Author YJ
 * @Date 2023/7/21 11:19
 * Description:
 */
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
        t1.setName("1号");
        t2.setName("2号");
        //设置2号为守护线程（备胎线程）
        //当1号线程结束了，2号线程就没有存在的必要了
        t2.setDaemon(true);
        t1.start();
        t2.start();
    }
}

package com.practice.threaddemo7;
/**
 * @Author YJ
 * @Date 2023/7/21 9:41
 * Description:
 */
public class MyThread extends Thread{
    @Override
    public void run() {
        //书写线程要执行的方法
        //getName()获取线程名
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "@" + i);
            Thread.yield();
        }
    }
}

package com.practice.threaddemo8;
/**
 * @Author YJ
 * @Date 2023/7/21 11:19
 * Description:
 */
public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.setName("1号");
        t1.start();
        //执行在main线程上的
        //当前线程：main线程
        //表示将t1线程插入到main线程之前
        t1.join();
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程" + i);
        }
    }
}