Java多线程的简单使用

使用多线程的利与弊

因为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方式，原因如下:

1. 避免了Java中类的单继承的局限性
2. 降低了线程任务对象和线程对象之间的耦合性
3. 代码可以被多个线程共享
4. 线程池只能放入实现了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");
    }
}