结合多本著作和个人开发经验，整理Java多线程入门手册

public class ThreadTest extends Thread{

    // run方法是 线程体,启动线程时会运行run()方法中的代码
    @Override
    public void run() {
        // 输出10以内偶数
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

public class ThreadMain {
    public static void main(String[] args) {
        // 1、创建线程对象
        ThreadTest t1 = new ThreadTest();
        // 2、调用start方法启动线程
        t1.start();
        System.out.println("主线程");
    }
}

public class RunnableImpl implements Runnable{

    @Override
    public void run() {
        // 输出10以内偶数
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

public class RunnableMain {
    public static void main(String[] args) {
        // 1、创建实现类对象
        RunnableImpl runnable = new RunnableImpl();
        // 2、创建线程对象，接收实现类，因为实现类中的run方法承载了线程的功能
        Thread t1 = new Thread(runnable);
        // 3、启动线程
        t1.start();
        // 主线程
        System.out.println("主线程");
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
// 1、实现Callable，指明泛型类型
public class CallableImpl implements Callable<List<Integer>> {

    // 2、线程返回Integer类型数据，抛出异常
    @Override
    public List<Integer> call() throws Exception {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0){
                // 3、偶数存储到集合中
                list.add(i);
            }
        }
        // 4、返回集合
        return list;
    }
}

import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

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

        // 1、创建Callable实现类对象
        CallableImpl callable = new CallableImpl();
        // 2、创建 FutureTask对象传入 callable
        // FutureTask 实现 了 RunnableFuture，RunnableFuture实现了Runnable接口和Future接口
        FutureTask<List<Integer>> task = new FutureTask<>(callable);
        // 3、将 task 传入线程对象
        Thread t1 = new Thread(task);
        // 4、启动线程
        t1.start();
        // 5、获取线程返回数据
        try {
            List<Integer> list = task.get();
            System.out.println(list);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public final static int MIN_PRIORITY = 1;


public final static int NORM_PRIORITY = 5;


public final static int MAX_PRIORITY = 10;

public class RunnableImpl implements Runnable{

    @Override
    public void run() {
        // 输出10以内偶数
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0){
                // 获取当前线程
                Thread thread = Thread.currentThread();
                // 获取线程名
                String threadName = thread.getName();
                System.out.println(threadName + "===>" + i);
            }
        }
    }
}

public class RunnableMain {
    public static void main(String[] args) {
        // 1、创建实现类对象
        RunnableImpl runnable = new RunnableImpl();
        // 2、 创建线程对象，并指定线程名
        Thread t1 = new Thread(runnable, "线程1");
        // 3、启动线程
        t1.start();

        System.out.println(Thread.currentThread().getName() + "主线程");
    }
}

public class RunnableMain {
    public static void main(String[] args) {
        // 1、创建实现类对象
        RunnableImpl runnable = new RunnableImpl();
        // 2、 创建线程对象，不指定名字
        Thread t1 = new Thread(runnable);
        // 设置线程名
        t1.setName("线程1");
        // 3、启动线程
        t1.start();

        System.out.println(Thread.currentThread().getName() + "主线程");
    }
}

public class RunnableImpl implements Runnable{

    @Override
    public void run() {
        // 输出10以内偶数
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0){
                try {
                    // 休眠1秒
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + "===>" + i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

public class RunnableMain {
    public static void main(String[] args) {
        // 1、创建实现类对象
        RunnableImpl runnable = new RunnableImpl();
        // 2、 创建线程对象，不指定名字
        Thread t1 = new Thread(runnable,"线程1");
        // 3、启动线程
        t1.start();
    }
}

public class RunnableImpl implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName() + "执行结束");
    }
}

public class RunnableMain {
    public static void main(String[] args) {
        // 1、创建实现类对象
        RunnableImpl runnable = new RunnableImpl();
        // 2、 创建线程对象，不指定名字
        Thread t1 = new Thread(runnable,"线程1");
        Thread t2 = new Thread(runnable,"线程2");
        // 3、启动线程
        t1.start();
        t2.start();
    }
}

public class RunnableMain {
    public static void main(String[] args) {
        // 1、lambda创建线程
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    // 模拟耗时操作
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + "join方法===>" + i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        // 2、 启动线程
        t1.start();
        try {
            // t1调用join 方法
            t1.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("main线程");
    }
}

public class RunnableMain {
    public static void main(String[] args) {
        // 1、lambda创建线程
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "线程优先级" + Thread.currentThread().getPriority());
        },"线程1");

        Thread t2 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "线程优先级" + Thread.currentThread().getPriority());
        },"线程2");
        // 2、设置线程优先级
        t1.setPriority(1);
        t2.setPriority(10);
        // 3、 启动线程
        t1.start();
        t2.start();

        System.out.println("main线程");
    }
}

public class RunnableImpl implements Runnable{
    // boolean变量标记是否需要继续执行
    private boolean flag = true;

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        // 循环执行，flag为false时停止
        while (flag) {
            System.out.println(Thread.currentThread().getName() + "正在运行");
        }
    }
}

public class RunnableMain {
    public static void main(String[] args) {
        RunnableImpl runnable = new RunnableImpl();
        Thread t1 = new Thread(runnable, "线程1");
        t1.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程====》" + i);
            // 当循环三次时
            if(i == 3) {
                // 设置flag值为false
                runnable.setFlag(false);
            }
        }
    }
}