使用多线程的利与弊
因为CPU的速度远远大于内存和硬盘的速度,所以使用多线程可以充分利用CPU,减少CPU等待时间,让程序响应更快;
但是多线程也会带来上下文切换的开销,并且这种开销并不廉价,所以如果没有必要,我们需要尽量减少上下文切换的开销。
什么什么是上下文切换?当CPU从执行一个线程切换到执行另外一个线程的时候,它需要先存储当前线程的本地的数据,程序指针等,然后载入另一个线程的本地数据,程序指针等,最后才开始执行。这种切换称为“上下文切换”(“context switch”)。CPU会在一个上下文中执行一个线程,然后切换到另外一个上下文中执行另外一个线程。
创建线程
通过继承Thread类来创建线程
class MyThread extends Thread{
@Override
public void run() {
System.out.println("run ......");
}
}
public class ThreadTest {
public static void main(String[] args) {
//创建线程对象, 并启动
new MyThread().start();
}
}
通过实现Runnable接口来创建线程
class MyThread implements Runnable{
@Override
public void run() {
System.out.println("run ......");
}
}
public class ThreadTest {
public static void main(String[] args) {
new Thread(new MyThread()).start();
}
}
两种方式,我们该使用哪种方式?推荐使用Runnable方式,原因如下:
- 避免了Java中类的单继承的局限性
- 降低了线程任务对象和线程对象之间的耦合性
- 代码可以被多个线程共享
- 线程池只能放入实现了Runnable或Callback类的线程, 不能放入继承Thread的类
优雅的关闭线程
系统提供了stop和destroy方法来强制关闭线程,但这些方法都是官方明确不推荐使用的,并且现在已经标注为@Deprecated,因为如果强制杀死线程,则线程中所使用的资源,例如文件描述符、网络连接等不能正常关闭。
因此,一个线程一旦运行起来,就不要去强行打断它,合理的关闭办法是让其运行完(也就是函数执行完毕),干净地释放掉所有资源,然后退出。
public class ThreadTest {
public static void main(String[] args) throws InterruptedException {
MyThread t1 = new MyThread();
t1.start();
Thread.sleep(100);
t1.stopThread(); //通知线程t1关闭
System.out.println("main exit");
}
}
class MyThread extends Thread{
//设置关闭标志位,为true时让线程结束执行
private boolean stopped = false;
@Override
public void run() {
while (!stopped){
try {
System.out.println("t1 .... ");
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void stopThread(){
this.stopped = true;
}
}
守护线程和非守护线程
默认都是非守护线程,当所有非守护线程线程都退出时,JVM进程就会退出;守护线程不影响整个JVM进程的退出,垃圾回收线程就是守护线程;
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
while (true){
try {
System.out.println("t1 .... ");
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
//设置t1为守护线程
t1.setDaemon(true);
t1.start();
//如果t1为守护线程,当main函数执行完毕,程序就退出了
//如果t1为非守护线程,当main执行完毕,如果t1还未执行完毕,需要等待t1执行完毕程序才会退出
System.out.println("main exit");
Join
A线程调用B线程的join方法,等待B线程执行完成;在B线程没有完成前,A线程阻塞。
class AThread implements Runnable{
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("a ........... ");
}
}
public class JoinDemo1 {
public static void main(String[] args) throws InterruptedException {
Thread a = new Thread(new AThread());
a.start();
//主线程调用a线程的join方法, 主线程会一直阻塞等待a线程执行完成
a.join();
System.out.println("main end");
}
}