【Java并发编程】深入分析Thread(七)
来源：互联网 发布：android 无法修改mac 编辑：程序博客网 时间：2024/06/15 21:28
一、线程
1.1什么是线程？
线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件（如某个信号量），逻辑上不可执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。 以上摘自－－－百度百科。
1.2 什么是线程安全性？
如果一个类可以安全地被多个线程使用，它就是线程安全的。你无法对此论述提出任何争议，但也无法从中得到更多有意义的帮助。那么我们如何辨别线程安全与非线程安全的类？我们甚至又该如何理解“安全”呢？任何一个合理的“线程安全性”定义，其关键在于“正确性”的概念。在<<JAVA并发编程实践>>书中作者是这样定义的：一个类是是线程安全的，是指在被多个线程访问时，类可以持续进行正确的行为。或当多个线程访问一个类时，如果不用考虑这些线程在运行时环境下的调度和交替执行，并且不需要额外的同步及在调用方代码不必作其他的协调，这个类的行为仍然是正确的，那么称这个类是线程安全的。
1.3 线程的六种状态
线程从创建到销毁期间有六种状态：
- New： 至今尚未启动的线程的状态。
- Runnable ：可运行线程的线程状态。
- Blocked ：受阻塞并且正在等待监视器锁的某一线程的线程状态。
- Waiting ：某一等待线程的线程状态。
- Timed_waiting：具有指定等待时间的某一等待线程的线程状态。
- Terminated：已终止线程的线程状态。线程已经结束执行。
- 如下图所示：
二、Thread类
2.1 属性
//线程名字，通过构造参数来指定private char name[];//表示线程的优先级,优先级越高，越优先被执行（最大值为10，最小值为1，默认值为5）private int priority;private Thread threadQ;private long eetop;/* Whether or not to single_step this thread. */private boolean single_step;//线程是否是守护线程:当所有非守护进程结束或死亡后，程序将停止 private boolean daemon = false;/* JVM state */private boolean stillborn = false;//将要执行的任务private Runnable target;/* 线程组表示一个线程的集合。此外，线程组也可以包含其他线程组。线程组构成一棵树，在树中，除了初始线程组外，每个线程组都有一个父线程组。 */private ThreadGroup group;/* The context ClassLoader for this thread */private ClassLoader contextClassLoader;/* The inherited AccessControlContext of this thread */private AccessControlContext inheritedAccessControlContext;/*第几个线程，在init初始化线程的时候用来赋给thread.name */ private static int threadInitNumber;private static synchronized int nextThreadNum() { return threadInitNumber++;}/* ThreadLocal values pertaining to this thread. This map is maintained * by the ThreadLocal class. */ThreadLocal.ThreadLocalMap threadLocals = null;/* * InheritableThreadLocal values pertaining to this thread. This map is * maintained by the InheritableThreadLocal class. */ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;/* * The requested stack size for this thread, or 0 if the creator did * not specify a stack size. It is up to the VM to do whatever it * likes with this number; some VMs will ignore it. */private long stackSize;/* * JVM-private state that persists after native thread termination. */private long nativeParkEventPointer;/* * Thread ID */private long tid;/* For generating thread ID */private static long threadSeqNumber;/* *线程从创建到最终的消亡，要经历若干个状态。 *一般来说，线程包括以下这几个状态：创建(new)、就绪(runnable)、运行(running)、阻塞(blocked)、time waiting、waiting、消亡（dead）。 * */private volatile int threadStatus = 0;2.3 start()操作
//启动新创建的线程public synchronized void start() { /** * This method is not invoked for the main method thread or "system" * group threads created/set up by the VM. Any new functionality added * to this method in the future may have to also be added to the VM. * * A zero status value corresponds to state "NEW". *//*这个方法不会被主线程调用或通过虚拟机系统线程组创建起来。未来任何添加到该方法里的新功能可能需要加入到虚拟机中 * * 状态new的值是0. * */ if (threadStatus != 0) throw new IllegalThreadStateException(); /* Notify the group that this thread is about to be started * so that it can be added to the group's list of threads * and the group's unstarted count can be decremented. */ /* 通知线程组新线程将要启动，以便它可以添加到线程组列表并且线程组没有开始计数*/ group.add(this); boolean started = false; try { start0(); started = true; } finally { try { if (!started) { group.threadStartFailed(this); } } catch (Throwable ignore) { /* do nothing. If start0 threw a Throwable then it will be passed up the call stack */ } }}2.3 run()操作
public void run() { if (target != null) { target.run(); } }2.4 start()和run()之间有什么区别？
2.4.1 代码示例：run()方法使用
package com.game.thread;/** * * @author liulongling * */public class ThreadTest extends Thread{public ThreadTest(String name) {super.setName(name);}@Overridepublic void run() {for(int i = 0; i < 5;i++){System.out.println(super.getName()+"："+i);}}public static void main(String[] args) {ThreadTest test = new ThreadTest("A");ThreadTest test1 = new ThreadTest("B");test.run();test1.run();if(Thread.activeCount()>=1){Thread.yield();}}}控制台：+------------------------------------------------------------------+A：0A：1A：2A：3A：4B：0B：1B：2B：3B：4
+------------------------------------------------------------------+
2.4.2 代码示例：start()方法使用
package com.game.thread;/** * * @author liulongling * */public class ThreadTest extends Thread{public ThreadTest(String name) {super.setName(name);}@Overridepublic void run() {for(int i = 0; i < 5;i++){System.out.println(super.getName()+"："+i);}}public static void main(String[] args) {ThreadTest test = new ThreadTest("A");ThreadTest test1 = new ThreadTest("B");test.start();test1.start();if(Thread.activeCount()>=1){Thread.yield();}}}控制台：+------------------------------------------------------------------+B：0A：0B：1A：1B：2A：2B：3A：3B：4A：4
+------------------------------------------------------------------+
2.4.3 结果分析
以上结果可以发现run()和单线程一样每次只能执行一个线程，而start()不一样有多个线程交叉执行着。我们知道start()方法被用来启动新创建的线程，而且start()内部通过本地系统调用了run()方法，这和直接调用run()方法的效果不一样。当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法会启动新的线程，其中多个线程在CPU中是支持并发执行的。那么有没有什么方法可以让A线程优先执行呢？2.5 setPriority()操作
public final void setPriority(int newPriority) { ThreadGroup g; checkAccess(); if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) { throw new IllegalArgumentException(); } if((g = getThreadGroup()) != null) { if (newPriority > g.getMaxPriority()) { newPriority = g.getMaxPriority(); } setPriority0(priority = newPriority); } }private native void setPriority0(int newPriority);setPriority使用了native关键字，在Java API中，一个native方法意味着这个方法没有使用Java语言实现，只能通过代码示例去分析它的原理。在代码中将线程A的执行优先级设置为最高，同时线程B的优先级设置为最低，那么预期的结果应该是线程A先执行完后再执行线程B，代码如下：
package com.game.thread;/** * * @author liulongling * */public class ThreadTest extends Thread{public ThreadTest(String name) {super.setName(name);}@Overridepublic void run() {for(int i = 0; i < 5;i++){System.out.println(super.getName()+"："+i);}}public static void main(String[] args) {ThreadTest test = new ThreadTest("A");ThreadTest test1 = new ThreadTest("B");//MAX_PRIORITY是最高优先级test.setPriority(MAX_PRIORITY);test.setPriority(MIN_PRIORITY);test.start();test1.start();if(Thread.activeCount()>=1){Thread.yield();}}}控制台：+------------------------------------------------------------------+A：0A：1A：2A：3A：4B：0B：1B：2B：3B：4+------------------------------------------------------------------+
2.5 sleep(long millis)操作
public static native void sleep(long millis) throws InterruptedException;
sleep也是使用了native关键字，调用了底层方法。sleep是指线程被调用时，占着CPU不工作，形象地说明为“占着CPU睡觉”，此时，系统的CPU部分资源被占用，其他线程无法进入。多线程下使用时需要注意的是sleep方法不会释放锁。比如：线程A和线程B执行一段加锁代码，线程A先进去，线程B在外面等待，其中代码程序有sleep方法让线程休眠，休眠后锁并不会被释放，线程B也只能继续在外面等待直到休眠时间结束。代码如下：
package com.game.thread;import java.io.IOException;/** * * @author liulongling * */public class ThreadTest{ private int i = 10; private Object object = new Object(); MyThread thread1 = new MyThread("A"); MyThread thread2 = new MyThread("B"); public static void main(String[] args) throws IOException { ThreadTest test = new ThreadTest(); test.thread1.start(); test.thread2.start(); } class MyThread extends Thread{ public MyThread(String name) { super.setName(name);} @Override public void run() { synchronized (object) { System.out.println(Thread.currentThread().getName()+":"+i++); try { System.out.println("线程"+Thread.currentThread().getName()+"进入睡眠状态"); Thread.currentThread().sleep(1000); } catch (InterruptedException e) { // TODO: handle exception } System.out.println("线程"+Thread.currentThread().getName()+"被唤醒"); System.out.println(Thread.currentThread().getName()+":"+i); } } }}控制台：+------------------------------------------------------------------+A:10
线程A进入睡眠状态
线程A被唤醒
A:11
B:11
线程B进入睡眠状态
线程B被唤醒
B:12
+------------------------------------------------------------------+
2.6 yield()操作
调用yield方法会让当前线程交出CPU权限，让CPU去执行其他的线程。它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。注意，调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。
2.7 isAlive()
/** * Tests if this thread is alive. A thread is alive if it has * been started and has not yet died. * * @return <code>true</code> if this thread is alive; * <code>false</code> otherwise. */ public final native boolean isAlive();表示线程当前是否为可用状态，如果线程已经启动，并且当前没有任何异常的话，则返回true，否则为false
2.8 join()操作
join有3个重载方法：2.8.1 join()
//立即阻塞调用线程，直到该线程执行结束public final synchronized void join(long millis)throws InterruptedException {long base = System.currentTimeMillis();long now = 0;if (millis < 0) {throw new IllegalArgumentException("timeout value is negative");}if (millis == 0) {//线程状态正常while (isAlive()) {wait(0);}} else {while (isAlive()) {long delay = millis - now;if (delay <= 0) {break;}wait(delay);now = System.currentTimeMillis() - base;}}}package com.game.thread;import java.io.IOException;/** * * @author liulongling * */public class ThreadTest{private int i = 10;private Object object = new Object();MyThread thread1 = new MyThread("A");MyThread thread2 = new MyThread("B");public static void main(String[] args) throws IOException {ThreadTest test = new ThreadTest();test.thread1.start();System.out.println("线程"+Thread.currentThread().getName()+"等待");try {test.thread1.join();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("线程"+Thread.currentThread().getName()+"执行");for (int j = 0; j < 5; j++){System.out.println(Thread.currentThread().getName() + ":" + j);}} class MyThread extends Thread{public MyThread(String name) {super.setName(name);}@Overridepublic void run() {synchronized (object) {System.out.println(Thread.currentThread().getName()+":"+i++);try {System.out.println("线程"+Thread.currentThread().getName()+"进入睡眠状态");Thread.currentThread().sleep(1000);} catch (InterruptedException e) {// TODO: handle exception}System.out.println("线程"+Thread.currentThread().getName()+"被唤醒");System.out.println(Thread.currentThread().getName()+":"+i);}}}}控制台：+------------------------------------------------------------------+MSDN上解释join无参方法其作用为：阻塞 “调用线程” 直到某个线程结束。从上面结果可以分析出，A线程其实在main线程上运行，我们可以说main线程调用了A线程或称main线程为“调用线程”，A线程调用join()方法后将调用线程阻塞直到A线程结束后控制台才输出来main:0...。我们去掉join方法看下控制台输出结果。线程main等待
A:10
线程A进入睡眠状态
线程A被唤醒
A:11
线程main执行
main:0
main:1
main:2
main:3
main:4
控制台：+------------------------------------------------------------------+main:0
main:1
A:10
main:2
线程A进入睡眠状态
main:3
main:4
线程A被唤醒
A:11
+------------------------------------------------------------------+
2.8.2 join(long millis)
join(long millis)的参数作用是指定“调用线程”的最大阻塞时间。代码如下：
package com.game.thread;import java.io.IOException;/** * * @author liulongling * */public class ThreadTest{private int i = 10;private Object object = new Object();MyThread thread1 = new MyThread("A");MyThread thread2 = new MyThread("B");public static void main(String[] args) throws IOException {ThreadTest test = new ThreadTest();test.thread1.start();System.out.println("线程"+Thread.currentThread().getName()+"等待");try {test.thread1.join(500);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("线程"+Thread.currentThread().getName()+"执行");for (int j = 0; j < 5; j++){System.out.println(Thread.currentThread().getName() + ":" + j);}} class MyThread extends Thread{public MyThread(String name) {super.setName(name);}@Overridepublic void run() {synchronized (object) {System.out.println(Thread.currentThread().getName()+":"+i++);try {System.out.println("线程"+Thread.currentThread().getName()+"进入睡眠状态");Thread.currentThread().sleep(1000);} catch (InterruptedException e) {// TODO: handle exception}System.out.println("线程"+Thread.currentThread().getName()+"被唤醒");System.out.println(Thread.currentThread().getName()+":"+i);}}}}从上面结果可以分析出，在A线程还未结束，主线程已经开始执行。原因是我们给主线程设置的阻塞时间是500ms，小于A线程run()方法里的1000ms休眠时间。线程main等待
A:10
线程A进入睡眠状态
线程main执行
main:0
main:1
main:2
main:3
main:4
线程A被唤醒
A:11
+------------------------------------------------------------------+
2.8.3 join(long millis, int nanos)
阻塞调用线程的时间最长为 millis 毫秒 + nanos 纳秒...这里就不举例说明了，原理和上一个方法一样。2.9 interrupt()操作
interrupt的作用是中断正被阻塞的线程，比如我给某一线程休眠了10s时间，如果我在这个线程上调用了interrupt方法，看看会有什么效果。代码如下：
package com.game.thread;import java.io.IOException;/** * * @author liulongling * */public class ThreadTest{private int i = 10;private Object object = new Object();MyThread thread1 = new MyThread("A");MyThread thread2 = new MyThread("B");public static void main(String[] args) throws IOException {ThreadTest test = new ThreadTest();test.thread1.start();test.thread1.interrupt();} class MyThread extends Thread{public MyThread(String name) {super.setName(name);}@Overridepublic void run() {synchronized (object) {System.out.println(Thread.currentThread().getName()+":"+i++);try {System.out.println("线程"+Thread.currentThread().getName()+"进入睡眠状态");Thread.currentThread().sleep(10000);} catch (InterruptedException e) {System.out.println("你被中断了");}System.out.println("线程"+Thread.currentThread().getName()+"被唤醒");System.out.println(Thread.currentThread().getName()+":"+i);}}}}控制台：+------------------------------------------------------------------+A:10
线程A进入睡眠状态
你被中断了
线程A被唤醒
A:11+------------------------------------------------------------------+
使用了 interrupt的结果是在休眠代码处抛出一个异常，并且阻塞马上停止了。
3.0 setDaemon()操作
用来设置线程是否成为守护线程和判断线程是否是守护线程。守护线程和用户线程的区别在于：守护线程依赖于创建它的线程，而用户线程则不依赖。举个简单的例子：如果在main线程中创建了一个守护线程，当main方法运行完毕之后，守护线程也会随着消亡。而用户线程则不会，用户线程会一直运行直到其运行完毕。在JVM中，像垃圾收集器线程就是守护线程。Thread类有一个比较常用的静态方法currentThread()用来获取当前线程。
参考资料
http://www.cnblogs.com/dolphin0520/p/3920357.html
作者：小毛驴，一个游戏人
梦想：世界和平
原文地址：http://blog.csdn.net/liulongling
本博客中未标明转载的文章归作者小毛驴所有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
4 1
- 【Java并发编程】深入分析Thread(七)
- java并发编程—— 七 Thread理解与死锁分析(哲学家进餐演示)
- 深入学习java并发编程：Thread类的使用
- Java并发编程--Thread
- 【Java并发编程】深入分析AtomicInteger(二)
- 【Java并发编程】深入分析synchronized(三)
- 【Java并发编程】深入分析volatile(四)
- 【Java并发编程】深入分析ThreadLocal(八)
- 【Java并发编程】深入分析ConcurrentHashMap(九)
- 【Java并发编程】深入分析AtomicInteger(二)
- 【Java并发编程】深入分析synchronized(三)
- 【Java并发编程】深入分析volatile(四)
- 【Java并发编程】深入分析ConcurrentHashMap(九)
- thread接口，java并发编程
- Java并发编程(一)----深入分析Volatile的实现原理
- 【1】Java 并发编程--深入分析Volatile的实现原理
- Java 并发编程深入学习——ThreadLocal 原理分析
- Java并发编程深入学习
- object-c 混编 调用C,C++接口
- JBossWeb/Tomcat 初始化连接器和处理 Http 请求过程
- HDU 2048 2049 (错排，排列组合)
- 读书笔记 JavaScript 高级程序设计（第三版）-- 第1章
- Java Request 获取域名
- 【Java并发编程】深入分析Thread(七)
- 质数的无穷性——从素数到数论
- Java线程间通过共享对象通信
- delete 与 deleteLater()
- rm删除破折号开头的文件或目录
- git修复commit记录
- 集锦——浏览器每次访问自动更新网页，不用手工设置，附Google/firefox/Ie
- Xcode 环境变量及路径设置
- scala学习：环境搭建
