java多线程（六）多线程的其他常用方法

线程的名称

如何设置和获取线程名称

1. 获取线程名称

使用this.getName()获取当前线程名称，
或者用Thread.currentThread()返回该线程对象。

//继承Thread类
class SingleThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 60; i++) {
            //Thread-0 sing thread running.....37
            System.out.println(this.getName() + " sing thread running....." + i);
        }
    }
}

2. 设置线程名称

public class MultipleThread {
    public static void main(String[] args) {
        SingleThread singleThread = new SingleThread();
        singleThread.setName("Single Thread");//设置线程名称
        singleThread.start();//开启线程
        for (int i = 0; i < 10; i++) {
            System.out.println("main is running" + i);
        }
    }
}
//继承Thread类
class SingleThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            //Thread.currentThread()返回当前正在运行的线程的该对象
            System.out.println(Thread.currentThread().getName() + " is running....." + i);//thread is running.....2
        }
    }
}

停止线程

stop()已过时
只有一种停止线程，就是等待run方法结束。开启多线程运行代码通常都是循环结构在run方法中。
所以只要控制循环就可以让控制run方法也就是线程的生命。

class StopThread implements Runnable {
    private boolean flag = true;
    @Override
    public void run() {
        int count = 0;
        while (flag){//当线程检测到共享标记为false的时候停止运行
            System.out.println(Thread.currentThread().getName() + " Thread is running..."+ count++);
        }
    }
     void setFlag(boolean flag) {
        this.flag = flag;
    }
}
public class LockTest {
    public static void main(String[] args) {
        StopThread stopThread = new StopThread();

        new Thread(stopThread).start();
        new Thread(stopThread).start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " "+ i);
            if (i == 20){
                stopThread.setFlag(false);//设置标记让线程停止
            }
        }
    }
}

interupt方法是唤醒线程的冻结状态，但是会抛出interupt异常，这个时候就可以catch这个异常来处理代码。

守护线程，后台线程

setDaemon()方法
定义：守护线程–也称“服务线程”，在没有用户线程可服务时会自动离开。
当一个线程设置为守护线程时，该后台线程会随前台线程结束而一起结束。
用个比较通俗的比如，任何一个守护线程都是整个JVM中所有非守护线程的保姆。
只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
Daemon的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC (垃圾回收器)，它就是一个很称职的守护者。

优先级：守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务。
设置：通过setDaemon(true)来设置线程为“守护线程”；将一个用户线程设置为守护线程的方式是在 start线程之前 用线程对象的setDaemon方法。
举例: 垃圾回收线程就是一个经典的守护线程，当我们的程序中不再有任何运行的 Thread,程序就不会再产生垃圾，垃圾回收器也就无事可做，所以当垃圾回收线程是JVM上仅剩的线程时，垃圾回收线程会自动离开。它始终在低级别的状态中运行，用于实时监控和管理系统中的可回收资源。
当JVM中所有的线程都是守护线程的时候，JVM就可以退出了；如果还有一个或以上的非守护线程则JVM不会退出。

public class Demon {
	public static void main(String[] args) {
		Thread deamon = new Thread(new DaemonRunner(),"DaemonRunner");
		//设置为守护线程，start线程之前调用
		deamon.setDaemon(true);
		deamon.start();//启动线程
	}
	
	
	static class DaemonRunner implements Runnable{
		@Override
		public void run() {
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}finally{
				System.out.println("这里的代码在java虚拟机退出时并不一定会执行哦！");
			}
		}
	}

join()方法

线程join()方法为该线程抢夺执行权。
作用：在一个A线程中临时加入一个B线程，A会等到B运行完，自己再运行。

class SingleThread implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName() + " thread is running..." + i);
        }
    }
}
public class LockTest {

    public static void main(String[] args) throws InterruptedException {
        SingleThread singleThread = new SingleThread();
        Thread t0 = new Thread(singleThread);
        Thread t1 = new Thread(singleThread);
        //开启线程t0
        t0.start();
        //执行join方法
        t0.join();
        //开启线程t1
        t1.start();
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName() + " thread is running..." + i);
        }
    }
}

我们发现当我们在主线程中使用

        //开启线程t0
        t0.start();
        //执行join方法
        t0.join();
        //开启线程t1
        t1.start();

t0.join方法时，这时主线程会进入冻结状态而把执行权交给t0，等待t0线程完全执行完之后，主线程才会醒来继续执行，然后再开启线程t1这时，主线程和t1交替执行。

如果我们调换join的顺序：

        //开启线程t0
        t0.start();
        //开启线程t1
        t1.start();
        //执行join方法
        t0.join();

这时线程t0和线程t1都启动了，再执行join方法，则主线程会等待，和t1没关系，所以t0和t1一起执行，等到t0执行完主线程才能加入继续执行。

用join的频率不是很高。