Thread类的基本使用

Thread表示线程, 也是Java中自带的一个类, 主要用于开辟新线程

五种创建线程的方式

public class TestCreateThread {

    class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("继承Thread, 重写run");
        }
    }

    class MyRunnable implements Runnable {

        @Override
        public void run() {
            System.out.println("实现Runnable, 重写run, 实例作参数");
        }

    }

    public static void main(String[] args) {

        //继承Thread, 重写run
        Thread t0 =  new TestCreateThread(). new MyThread();

        //实现Runnable, 重写run, 实例作参数
        Thread t1 = new Thread(new TestCreateThread(). new MyRunnable());

        //使用匿名内部类, 重写run
        Thread t2 = new Thread() {
            @Override
            public void run() {
                System.out.println("使用匿名内部类, 重写run");
            }
        };

        //使用匿名内部类, 实现Runnable接口, 实例作参数
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("使用匿名内部类, 实现Runnable接口, 实例作参数");
            }
        });

        //使用lambda表达式
        Thread t4 = new Thread( () -> {
            System.out.println("使用lambda表达式");
        });

        t0.start();
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

}

结果输出

所以说每个线程创建并开启(start方法 == 启动线程)后都会自动调用run方法, 这个run方法可以是Runnable方法里的也可以是Thread类里的. 所以说lambda表达式默认是在重写run方法??

btw, 上面的输出是无序的随机的, 每个线程工作的时间不一定和之前相同.

线程的开始和结束

 JVM中, 操作系统线程API中, 内核PCB中都有一个线程id, Thread对象出来只是在JVM中创建了对象, start方法调用后才会在内核中创建线程.

 start和run的区别

run没有真正创建线程, start才是真正创建了线程, 如:

public class Main {

    static class MyThread extends Thread {
        Thread t0 = new Thread(() -> {
            while (true) {
                System.out.println("t0线程进行中");
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
    }

    public static void main(String[] args) {

        MyThread myThread = new MyThread();
        myThread.t0.run();

        System.out.println("main线程执行结束");
    }
}

         结果是run后面的sout语句一直没有被执行, 因为直接调用run没有创建新线程, 只是在main线程里执行了run方法, run方法又是一个死循环, 相当于run语句没有执行不会结束, 所以sout不会被执行. 若改run为start, 就会开辟新线程, 开辟后start方法就相当于执行结束, 之后的run语句都是在新线程中执行, 不影响main线程后面的语句执行.

多线程使用出bug的经典问题

public class Main {

    public static long counter = 0;

    static class ThreadT extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 50_0000; i++) {
                counter++;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadT t1 = new ThreadT();
        ThreadT t2 = new ThreadT();

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(counter);
    }
}
//输出随机数(通常大于50_0000)

        想通过多线程提高内核的性能利用率, 但是造成出错, 原因是因为虽然线程之间相对独立, 但是共用一份文件资源和内存, 从全局变量counter的角度来看, 它可能同时会被t1, t2两个线程取走, 但是计算时候他们都要使用同一块内存, 前者计算完得到的结果被可能被后者得到的相同结果取代. 简言之, 两个线程的读档和写档的时间差导致了计算的误差, 造成线程不安全.