Java并发编程：Thread类的使用

时间 2019-11-13 标签 java 并发编程 thread 使用

Java并发编程：Thread类的使用html

　　在前面2篇文章分别讲到了线程和进程的由来、以及如何在Java中怎么建立线程和进程。今天咱们来学习一下Thread类，在学习Thread类以前，先介绍与线程相关知识：线程的几种状态、上下文切换，而后接着介绍Thread类中的方法的具体使用。java

　　如下是本文的目录大纲：编程

　　一.线程的状态安全

　　二.上下文切换多线程

　　三.Thread类中的方法并发

　　如有不正之处，请多多谅解并欢迎批评指正。ide

　　请尊重做者劳动成果，转载请标明原文连接：学习

　　http://www.cnblogs.com/dolphin0520/p/3920357.htmlthis

一.线程的状态

　　在正式学习Thread类中的具体方法以前，咱们先来了解一下线程有哪些状态，这个将会有助于后面对Thread类中的方法的理解。spa

　　线程从建立到最终的消亡，要经历若干个状态。通常来讲，线程包括如下这几个状态：建立(new)、就绪(runnable)、运行(running)、阻塞(blocked)、time waiting、waiting、消亡（dead）。

　　当须要新起一个线程来执行某个子任务时，就建立了一个线程。可是线程建立以后，不会当即进入就绪状态，由于线程的运行须要一些条件（好比内存资源，在前面的JVM内存区域划分一篇博文中知道程序计数器、Java栈、本地方法栈都是线程私有的，因此须要为线程分配必定的内存空间），只有线程运行须要的全部条件知足了，才进入就绪状态。

　　当线程进入就绪状态后，不表明马上就能获取CPU执行时间，也许此时CPU正在执行其余的事情，所以它要等待。当获得CPU执行时间以后，线程便真正进入运行状态。

　　线程在运行状态过程当中，可能有多个缘由致使当前线程不继续运行下去，好比用户主动让线程睡眠（睡眠必定的时间以后再从新执行）、用户主动让线程等待，或者被同步块给阻塞，此时就对应着多个状态：time waiting（睡眠或等待必定的事件）、waiting（等待被唤醒）、blocked（阻塞）。

　　当因为忽然中断或者子任务执行完毕，线程就会被消亡。

　　下面这副图描述了线程从建立到消亡之间的状态：

　　在有些教程上将blocked、waiting、time waiting统称为阻塞状态，这个也是能够的，只不过这里我想将线程的状态和Java中的方法调用联系起来，因此将waiting和time waiting两个状态分离出来。

二.上下文切换

　　对于单核CPU来讲（对于多核CPU，此处就理解为一个核），CPU在一个时刻只能运行一个线程，当在运行一个线程的过程当中转去运行另一个线程，这个叫作线程上下文切换（对于进程也是相似）。

　　因为可能当前线程的任务并无执行完毕，因此在切换时须要保存线程的运行状态，以便下次从新切换回来时可以继续切换以前的状态运行。举个简单的例子：好比一个线程A正在读取一个文件的内容，正读到文件的一半，此时须要暂停线程A，转去执行线程B，当再次切换回来执行线程A的时候，咱们不但愿线程A又从文件的开头来读取。

　　所以须要记录线程A的运行状态，那么会记录哪些数据呢？由于下次恢复时须要知道在这以前当前线程已经执行到哪条指令了，因此须要记录程序计数器的值，另外好比说线程正在进行某个计算的时候被挂起了，那么下次继续执行的时候须要知道以前挂起时变量的值时多少，所以须要记录CPU寄存器的状态。因此通常来讲，线程上下文切换过程当中会记录程序计数器、CPU寄存器状态等数据。

　　说简单点的：对于线程的上下文切换实际上就是存储和恢复CPU状态的过程，它使得线程执行可以从中断点恢复执行。

　　虽然多线程可使得任务执行的效率获得提高，可是因为在线程切换时一样会带来必定的开销代价，而且多个线程会致使系统资源占用的增长，因此在进行多线程编程时要注意这些因素。

三.Thread类中的方法

　　经过查看java.lang.Thread类的源码可知：

　　Thread类实现了Runnable接口，在Thread类中，有一些比较关键的属性，好比name是表示Thread的名字，能够经过Thread类的构造器中的参数来指定线程名字，priority表示线程的优先级（最大值为10，最小值为1，默认值为5），daemon表示线程是不是守护线程，target表示要执行的任务。

　　下面是Thread类中经常使用的方法：

　　如下是关系到线程运行状态的几个方法：

　　1）start方法

　　start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程当中，会为相应的线程分配须要的资源。

　　2）run方法

　　run()方法是不须要用户来调用的，当经过start方法启动一个线程以后，当线程得到了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。

　　3）sleep方法

　　sleep方法有两个重载版本：

sleep(long millis)     //参数为毫秒

sleep(long millis,int nanoseconds)    //第一参数为毫秒，第二个参数为纳秒

　　sleep至关于让线程睡眠，交出CPU，让CPU去执行其余的任务。

　　可是有一点要很是注意，sleep方法不会释放锁，也就是说若是当前线程持有对某个对象的锁，则即便调用sleep方法，其余线程也没法访问这个对象。看下面这个例子就清楚了：

public class Test {
	
	private int i = 10;
	private Object object = new Object();
	
    public static void main(String[] args) throws IOException  {
    	Test test = new Test();
    	MyThread thread1 = test.new MyThread();
    	MyThread thread2 = test.new MyThread();
    	thread1.start();
    	thread2.start();
    }  
    
    
    class MyThread extends Thread{
    	@Override
    	public void run() {
    		synchronized (object) {
				i++;
				System.out.println("i:"+i);
				try {
					System.out.println("线程"+Thread.currentThread().getName()+"进入睡眠状态");
					Thread.currentThread().sleep(10000);
				} catch (InterruptedException e) {
					// TODO: handle exception
				}
				System.out.println("线程"+Thread.currentThread().getName()+"睡眠结束");
				i++;
				System.out.println("i:"+i);
			}
    	}
    }
}

　　输出结果：

　　从上面输出结果能够看出，当Thread-0进入睡眠状态以后，Thread-1并无去执行具体的任务。只有当Thread-0执行完以后，此时Thread-0释放了对象锁，Thread-1才开始执行。

　　注意，若是调用了sleep方法，必须捕获InterruptedException异常或者将该异常向上层抛出。当线程睡眠时间满后，不必定会当即获得执行，由于此时可能CPU正在执行其余的任务。因此说调用sleep方法至关于让线程进入阻塞状态。

　　4）yield方法

　　调用yield方法会让当前线程交出CPU权限，让CPU去执行其余的线程。它跟sleep方法相似，一样不会释放锁。可是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。

　　注意，调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只须要等待从新获取CPU执行时间，这一点是和sleep方法不同的。

　　5）join方法

　　join方法有三个重载版本：

join()
join(long millis)     //参数为毫秒
join(long millis,int nanoseconds)    //第一参数为毫秒，第二个参数为纳秒

　　假如在main线程中，调用thread.join方法，则main方法会等待thread线程执行完毕或者等待必定的时间。若是调用的是无参join方法，则等待thread执行完毕，若是调用的是指定了时间参数的join方法，则等待必定的事件。

　　看下面一个例子：

public class Test {
	
    public static void main(String[] args) throws IOException  {
    	System.out.println("进入线程"+Thread.currentThread().getName());
    	Test test = new Test();
    	MyThread thread1 = test.new MyThread();
    	thread1.start();
    	try {
    		System.out.println("线程"+Thread.currentThread().getName()+"等待");
			thread1.join();
			System.out.println("线程"+Thread.currentThread().getName()+"继续执行");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }  
    
    class MyThread extends Thread{
    	@Override
    	public void run() {
    		System.out.println("进入线程"+Thread.currentThread().getName());
    		try {
    			Thread.currentThread().sleep(5000);
			} catch (InterruptedException e) {
				// TODO: handle exception
			}
    		System.out.println("线程"+Thread.currentThread().getName()+"执行完毕");
    	}
    }
}

　　输出结果：

　　能够看出，当调用thread1.join()方法后，main线程会进入等待，而后等待thread1执行完以后再继续执行。

　　实际上调用join方法是调用了Object的wait方法，这个能够经过查看源码得知：

　　wait方法会让线程进入阻塞状态，而且会释放线程占有的锁，并交出CPU执行权限。

　　因为wait方法会让线程释放对象锁，因此join方法一样会让线程释放对一个对象持有的锁。具体的wait方法使用在后面文章中给出。

　　6）interrupt方法

　　interrupt，顾名思义，即中断的意思。单独调用interrupt方法可使得处于阻塞状态的线程抛出一个异常，也就说，它能够用来中断一个正处于阻塞状态的线程；另外，经过interrupt方法和isInterrupted()方法来中止正在运行的线程。

　　下面看一个例子：

public class Test {
	
    public static void main(String[] args) throws IOException  {
    	Test test = new Test();
    	MyThread thread = test.new MyThread();
    	thread.start();
    	try {
			Thread.currentThread().sleep(2000);
		} catch (InterruptedException e) {
			
		}
    	thread.interrupt();
    }  
    
    class MyThread extends Thread{
    	@Override
    	public void run() {
    		try {
    			System.out.println("进入睡眠状态");
				Thread.currentThread().sleep(10000);
				System.out.println("睡眠完毕");
			} catch (InterruptedException e) {
				System.out.println("获得中断异常");
			}
    		System.out.println("run方法执行完毕");
    	}
    }
}

　　输出结果：

　　从这里能够看出，经过interrupt方法能够中断处于阻塞状态的线程。那么能不能中断处于非阻塞状态的线程呢？看下面这个例子：

public class Test {
	
    public static void main(String[] args) throws IOException  {
    	Test test = new Test();
    	MyThread thread = test.new MyThread();
    	thread.start();
    	try {
			Thread.currentThread().sleep(2000);
		} catch (InterruptedException e) {
			
		}
    	thread.interrupt();
    }  
    
    class MyThread extends Thread{
    	@Override
    	public void run() {
    		int i = 0;
    		while(i<Integer.MAX_VALUE){
    			System.out.println(i+" while循环");
    			i++;
    		}
    	}
    }
}

　　运行该程序会发现，while循环会一直运行直到变量i的值超出Integer.MAX_VALUE。因此说直接调用interrupt方法不能中断正在运行中的线程。

　　可是若是配合isInterrupted()可以中断正在运行的线程，由于调用interrupt方法至关于将中断标志位置为true，那么能够经过调用isInterrupted()判断中断标志是否被置位来中断线程的执行。好比下面这段代码：

public class Test {
	
    public static void main(String[] args) throws IOException  {
    	Test test = new Test();
    	MyThread thread = test.new MyThread();
    	thread.start();
    	try {
			Thread.currentThread().sleep(2000);
		} catch (InterruptedException e) {
			
		}
    	thread.interrupt();
    }  
    
    class MyThread extends Thread{
    	@Override
    	public void run() {
    		int i = 0;
    		while(!isInterrupted() && i<Integer.MAX_VALUE){
    			System.out.println(i+" while循环");
    			i++;
    		}
    	}
    }
}

　　运行会发现，打印若干个值以后，while循环就中止打印了。

　　可是通常状况下不建议经过这种方式来中断线程，通常会在MyThread类中增长一个属性 isStop来标志是否结束while循环，而后再在while循环中判断isStop的值。

class MyThread extends Thread{
    	private volatile boolean isStop = false;
    	@Override
    	public void run() {
    		int i = 0;
    		while(!isStop){
    			i++;
    		}
    	}
    	
    	public void setStop(boolean stop){
    		this.isStop = stop;
    	}
    }

　　那么就能够在外面经过调用setStop方法来终止while循环。

　　7）stop方法

　　stop方法已是一个废弃的方法，它是一个不安全的方法。由于调用stop方法会直接终止run方法的调用，而且会抛出一个ThreadDeath错误，若是线程持有某个对象锁的话，会彻底释放锁，致使对象状态不一致。因此stop方法基本是不会被用到的。

　　8）destroy方法

　　destroy方法也是废弃的方法。基本不会被使用到。

　　如下是关系到线程属性的几个方法：

　　1）getId

　　用来获得线程ID

　　2）getName和setName

　　用来获得或者设置线程名称。

　　3）getPriority和setPriority

　　用来获取和设置线程优先级。