Java线程创建与Thread类的使用方法

class MyThread extends Thread{
    //重写run方法
    @Override
    public void run() {
        System.out.println("你好!线程!");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        //创建MyThread线程对象，但是线程没有创建
        Thread thread = new MyThread();
        //线程创建并运行
        thread.start();
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("使用Runnable描述任务!");
    }
}

public class TestDemo3 {
    public static void main(String[] args) {
        //将Runnable任务传给Thread对象来创建运行线程
        Runnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);

        thread.start();
    }
}

public class TestDemo4 {
    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("使用匿名内部类创建线程匿名对象");
            }
        };
        thread.start();
    }
}

public class TestDemo6 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> System.out.println("使用Lambda表达式表示匿名内部类来创建匿名任务"));
        thread.start();
    }
}

public class TestDemo7 {
    public static void main(String[] args) {
        //thread 线程
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("thread线程执行中！");
                    //为了使效果更加明显 可以使用sleep方法设定线程睡眠时间
                    try {
                        Thread.sleep(1000);//每执行一次循环就睡眠1秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        thread.start();

        //main 线程
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程执行中！");
            //为了使效果更加明显 可以使用sleep方法设定线程睡眠时间
            try {
                Thread.sleep(1000);//每执行一次循环就睡眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Test {
    private static final long COUNT = 20_0000_0000L;
    //两个线程
    public static void many() throws InterruptedException {
        //获取开始执行时间戳
        long start = System.currentTimeMillis();

        Thread thread1 = new Thread(() -> {
            long a = 0;
            for (long i = 0; i < COUNT; i++) {
                a++;
            }
        });
        thread1.start();
        Thread thread2 = new Thread(() -> {
            long b = 0;
            for (long i = 0; i < COUNT; i++) {
                b++;
            }
        });
        thread2.start();

        //等待两个线程结束 再获取结束时的时间戳
        thread1.join();
        thread2.join();
        long end = System.currentTimeMillis();

        //执行时间，单位为毫秒
        System.out.println("多线程执行时间：" + (end - start) + "ms");
    }
    //单线程
    public static void single() {
        //记录开始执行的时间戳
        long start = System.currentTimeMillis();

        long a = 0;
        for (long i = 0; i < COUNT; i++) {
            a++;
        }
        long b = 0;
        for (long i = 0; i < COUNT; i++) {
            b++;
        }
        //获取执行结束时的时间戳
        long end = System.currentTimeMillis();
        System.out.println("单线程执行时间：" + (end - start) + "ms");
    }

    public static void main(String[] args) throws InterruptedException {
        //多线程
        many();
        //单线程
        single();
    }
}

public class TestDemo8 {
    private static boolean isQuit = false;
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while(!isQuit) {
                //每隔1秒打印一句
                System.out.println("一个不起眼的线程！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        //main线程阻塞5秒 按理会打印5句话
        Thread.sleep(5000);
        isQuit = true;
    }
}

public class TestDemo9 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() ->{
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("又是一个不起眼的线程！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();

        //main休眠5秒
        Thread.sleep(5000);

        //使用interrupt方法修改线程标志位，使其中断
        thread.interrupt();
    }
}

public class TestDemo9 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() ->{
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("又是一个不起眼的线程！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //收尾工作
                    System.out.println("收尾工作！");
                    break;
                }
            }
        });
        thread.start();

        //main休眠5秒
        Thread.sleep(5000);

        //使用interrupt方法修改线程标志位，使其中断
        thread.interrupt();
    }
}

public class TestDemo10 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (!Thread.interrupted()) {
                System.out.println("又又是一个不起眼的线程！");
                try {
                	//设置打印频率为1s
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //收尾工作
                    System.out.println("收尾工作！");
                    break;
                }
            }
        });
        thread.start();

        //main休眠5秒
        Thread.sleep(5000);

        //使用interrupt方法修改线程标志位，使其中断
        thread.interrupt();
    }
}