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两个线程取走, 但是计算时候他们都要使用同一块内存, 前者计算完得到的结果被可能被后者得到的相同结果取代. 简言之, 两个线程的读档和写档的时间差导致了计算的误差, 造成线程不安全.