概述
public enumState {/*** Thread state for a thread which has not yet started.*/NEW,/*** Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.*/RUNNABLE,/*** Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@linkObject#wait() Object.wait}.*/BLOCKED,/*** Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
*
*
{@linkObject#wait() Object.wait} with no timeout*
{@link#join() Thread.join} with no timeout*
{@linkLockSupport#park() LockSupport.park}*
*
*
A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called Object.wait()
* on an object is waiting for another thread to call
* Object.notify() or Object.notifyAll() on
* that object. A thread that has called Thread.join()
* is waiting for a specified thread to terminate.*/WAITING,/*** Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
*
*
{@link#sleep Thread.sleep}*
{@linkObject#wait(long) Object.wait} with timeout*
{@link#join(long) Thread.join} with timeout*
{@linkLockSupport#parkNanos LockSupport.parkNanos}*
{@linkLockSupport#parkUntil LockSupport.parkUntil}*
*/TIMED_WAITING,/*** Thread state for a terminated thread.* The thread has completed execution.*/TERMINATED;
}
新建状态
线程对象创建后，就进入新建状态 Thread thread = new Thread
就绪状态
调用start()方法，线程进入就绪状态，但并不意味着线程就立即执行，只是说明此线程已经做好准备，随时等待CPU调度执行。
阻塞状态
多个线程同时竞争一个独占锁，其他未抢到锁的线程，就进入阻塞状态被放置到锁池中，直到获取到锁，进入就绪状态
等待状态
该线程需要等待其他线程做出一些特定动作，通知或者是中断，等待其被其他线程唤醒，像CountDownLatch就可以等待一个或者几个线程结束。
超时等待状态
和等待状态不同的是，它可以在指定的时间自行的返回，sheep(long)函数就会让线程进入超时等待状态，时间到了才会转入就绪状态。
运行状态(Running)
CPU调度处于就绪状态的线程时，这个线程才真正执行，进入运行状态。
终止状态
线程正常执行完毕后或提前强制性终止或出现异常，线程就要销毁，释放资源。
Java创建线程的两种方式
继承Thread类
public class ThreadDemo1 extendsThread {
@Overridepublic voidrun(){for (int i = 0; i < 10; i++) {
System.out.println("当前执行的线程是" +Thread.currentThread().getName());
}
}public static voidmain(String[] args) {
ThreadDemo1 threadDemo1= newThreadDemo1();
ThreadDemo1 threadDemo2= newThreadDemo1();
threadDemo1.start();
threadDemo2.start();
}
}
执行结果是不确定的
实现Runnable
public class ThreadDemo2 implementsRunnable {
@Overridepublic voidrun() {for (int i = 0; i < 10; i++) {for (int j = 0;j < 1000; ++j){
System.out.println(i+ "当前执行的线程是" +Thread.currentThread().getName());
}
}
}public static voidmain(String[] args) {
ThreadDemo2 threadDemo1= newThreadDemo2();
ThreadDemo2 threadDemo2= newThreadDemo2();
Thread thread1= newThread(threadDemo1);
Thread thread2= newThread(threadDemo2);
thread1.start();
thread2.start();
System.out.println("当前线程是===>" +Thread.currentThread().getName());
}
}
主线程的名字为main，非主线程的名字是由虚拟机来指定的，同时，我们也可以为线程指定具体的名称。
我们保证每个线程都能正常启动，并不意味着它会按顺序的执行，因为调度程序是无法保证它的执行次序的，同时，run()函数结束时，意味着该线程的任务完成了。
注意：调用线程要调用start，如果调用run，那仅仅是简单的对象调用。
线程的方法调用
获取线程基本信息
public classThreadDemo6 {public static voidmain(String[] args) {
Thread thread= newThread(){
@Overridepublic voidrun(){/*获取线程唯一id标识*/
long id = this.getId();
System.out.println("thread的ID==>" +id);/*获取线程名字*/String name= this.getName();
System.out.println("thread的名字==>" +name);/*获取线程的优先级 默认5 1-10*/
int priority = this.getPriority();
System.out.println("thread的优先等级==>" +priority);/*查看当前线程是否为守护线程*/
boolean isDaemon = this.isDaemon();
System.out.println("thread是否为守护线程==>" +isDaemon);/*查看线程是否被中断*/
boolean isInterrupted = this.isInterrupted();
System.out.println("thread是否被中断==>" +isInterrupted);
}
};
thread.start();
}
}
执行结果
thread的ID==>11thread的名字==>Thread-0thread的优先等级==>5thread是否为守护线程==>falsethread是否被中断==>false
Thread.yield()
public class ThreadDemo1 implementsRunnable {protected int countDown = 10;private static int taskCount = 0;private final int id = taskCount++;publicThreadDemo1(){}public ThreadDemo1(intcountDown){this.countDown =countDown;
}publicString status(){return "#" + id + "(" + (countDown > 0 ? countDown : "stop!") + ")";
}
@Overridepublic voidrun() {while (countDown-- > 0){
System.out.println(status()+ " ");
Thread.yield();
}
}public static voidmain(String[] args) {for (int i = 0; i < 3; i++){new Thread(newThreadDemo1()).start();
}
}
}
#0(9)#0(8)#0(7)#0(6)#0(5)#0(4)#0(3)#0(2)#0(1)#0(stop!)
#1(9)#1(8)#1(7)#1(6)#1(5)#1(4)#1(3)#1(2)#1(1)#1(stop!)
#2(9)#2(8)#2(7)#2(6)#2(5)#2(4)#2(3)#2(2)#2(1)#2(stop!)
这个是一个倒计时的任务，对Thread.yield()调用是对线程调度器的一种建议，它在声明“我已经执行完生命周期中最重要的部分了，此刻正是切换给其他任务执行一段时间的大好时机”，说白就是自己按暂停键，让出自己CPU的使用权限，转为就绪状态，至于下一次什么时候能获得CPU调度就不一定了，有时很快，有时得等上一会。
Thread.sleep
public class ThreadDemo1 implementsRunnable {protected int countDown = 10;private static int taskCount = 0;private final int id = taskCount++;publicThreadDemo1(){}public ThreadDemo1(intcountDown){this.countDown =countDown;
}publicString status(){return "#" + id + "(" + (countDown > 0 ? countDown : "stop!") + ")";
}
@Overridepublic voidrun() {try{while (countDown-- > 0){
System.out.println(status());
Thread.sleep(1000);
}
}catch(InterruptedException e) {
e.printStackTrace();
}
}public static voidmain(String[] args) {for (int i = 0; i < 3; i++){new Thread(newThreadDemo1()).start();
}
}
}
Thread.sleep(long)将使“正在执行的任务“中止执行给定的时间(暂停执行)并且让出CPU使用权，这个语句相当于说在接下来的1秒内，你都不要叫我，我想睡一会，1秒睡眠时间过后，它自动转为就绪状态，但CPU不一定马上执行这个睡醒的线程，这要取决于是否抢到CPU时间片段。值得注意的是如果sleep和yield上下文被加锁了，它们依然使用锁，不会去释放。而sleep与yield最大的不同是，yield不会让线程进入等待状态，只是把线程转为就绪状态，并把CPU执行机会让步给优先级相同或者更高的线程，而sleep能控制具体交出CPU的使用时间。
Thread.currentThread()
public class ThreadDemo2 extendsThread {static{
System.out.println("静态块执行的线程===>" +Thread.currentThread().getName());
}
{
System.out.println("非静态块执行的线程是====>" +Thread.currentThread().getName());
System.out.println("this.getName()1=====>" + this.getName());
}publicThreadDemo2(){
System.out.println("构造方法内执行的线程====>" +Thread.currentThread().getName());
System.out.println("this.getName()2=====>" + this.getName());
}
@Overridepublic voidrun() {
System.out.println("当前执行的线程为====>" +Thread.currentThread().getName());
System.out.println("this.getName()3=====>" + this.getName());
}public static voidmain(String[] args) {
ThreadDemo2 threadDemo2= newThreadDemo2();
threadDemo2.start();
}
}
执行结果
静态块执行的线程===>main
非静态块执行的线程是====>mainthis.getName()1=====>Thread-0构造方法内执行的线程====>mainthis.getName()2=====>Thread-0当前执行的线程为====>Thread-0
this.getName()3=====>Thread-0
currentThread返回的是当前正在执行线程对象的引用，它与this.getName()有明显的不同，执行静态块，非静态块，构造方法的线程是main，而非ThreadDemo2，在执行run()方法的才是实例化的线程threadDemo2。所以在当前执行的Thread未必就是Thread本身。
isAlive()
public class ThreadDemo3 extendsThread {
@Overridepublic voidrun(){
System.out.println("执行执行====" + this.isAlive());
}public static voidmain(String[] args) {
ThreadDemo3 threadDemo3= newThreadDemo3();
System.out.println("begin===>" +threadDemo3.isAlive());
threadDemo3.start();
System.out.println("end==>" +threadDemo3.isAlive());
}
}
begin===>falseend==>true执行执行====true
isAlive()检测线程是否处于活动状态，活动状态返回true
setPriority()
优先级设定，优先级高的线程越容易获取CPU使用权，
public classThreadDemo4 {public static voidmain(String[] args) {for (int i = 0; i < 5; ++i){
Thread1 thread1= newThread1();
thread1.setPriority(6);
Thread2 thread2= newThread2();
thread2.setPriority(4);
thread2.start();
thread1.start();
}
}
}class Thread1 extendsThread{
@Overridepublic voidrun(){for (int i = 0; i < 100000; ++i){
System.out.println("+++++++++++++");
}
}
}class Thread2 extendsThread{
@Overridepublic voidrun(){for (int i = 0; i < 100000; ++i){
System.out.println("--------------");
}
}
}
执行结果
+++++++++++++
+++++++++++++
+++++++++++++
+++++++++++++
+++++++++++++
+++++++++++++
+++++++++++++
+++++++++++++
...
CPU会将资源尽量让给优先级高的线程
setDaemon()
守护线程，也有人叫后天线程，我们创建出来的线程默认都是前台线程，在使用上来说，守护线程和前台线程是没啥区别，区别在于进程结束，当一个进程中的所有前台线程都结束时，无论这个进程中的守护线程是否还在运行都要强制将他们结束。也就是说前台线程都结束了，守护线程也会自动销毁，它是为其他线程提供便利而存在的。
/*rose与jack*/
public classThreadDemo5 {public static voidmain(String[] args) {
Rose rose= newRose();
Jack jack= newJack();/*设置为守护线程必须在线程未启动之前*/jack.setDaemon(true);
rose.start();
jack.start();
}
}class Rose extendsThread{
@Overridepublic voidrun(){for (int i = 0; i < 5; ++i){
System.out.println("rose: let me go!");try{
Thread.sleep(1000);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("成功跳水");
}
}class Jack extendsThread{
@Overridepublic voidrun(){while (true){
System.out.println("jack:you jump! i jump!");try{
Thread.sleep(1000);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
}
}
执行结果
rose: let me go!jack:you jump! i jump!rose: let me go!jack:you jump! i jump!rose: let me go!jack:you jump! i jump!rose: let me go!jack:you jump! i jump!rose: let me go!jack:you jump! i jump!成功跳水
jack守护着rose，jack是守护线程，当rose跳水后，jack认为自己也没有活着的必要了，也自己销毁了，但注意一点是这当中还有一个第三者main，需要main也运行完jack线程才会销毁。
join()
这个方法可以协调多个线程同步运行，多线程运行本身是设计异步运行的，但在程序运行业务中，有可能线程A的计算需要线程B的返回结果，这就需要他们执行各自任务时要有先后，join就需要协调这些线程同步运行。
public classThreadDemo6 {private static boolean isFinish = false;public static voidmain(String[] args) {
Thread download= newThread(){
@Overridepublic voidrun(){
System.out.println("下载图片中.....");for (int i = 1; i <= 100; ++i){
System.out.println("下载进度" + i + "%");try{
Thread.sleep(1000);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("图片下载完毕");
isFinish= true;
}
};
Thread show= newThread(){
@Overridepublic voidrun(){
System.out.println("开始显示图片...");try{
download.join();
}catch(InterruptedException e) {
e.printStackTrace();
}if (!isFinish){throw new RuntimeException("图片下载出错");
}
System.out.println("图片正常展示。。。");
}
};
download.start();
show.start();
}
}
执行结果
下载图片中.....
开始显示图片...
下载进度1%下载进度2%...
下载进度100%图片下载完毕
图片正常展示。。。
show调用join会使show无限阻塞，直到down线程销毁为止，它和sleep最大的区别是join会释放锁，而sleep不会。
涉及到jmm内存模型，线程安全等，后面在介绍
1204
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
