java基础知识回顾之java Thread类学习(十)--线程的状态以及转化使用的方法介绍

   线程的概述:

        线程是程序的多个执行路径,执行调度的单位,依托于进程存在。线程不仅可以共享进程的内存,而且还拥有一个属于自己的内存空间,这段内存空间叫做线程栈,是建立线程的时候由系统分配的,主要用来保存线程内部的数据,如线程执行函数中定义的变量。

    java中多线程是一种抢占机制而不是分时机制。抢占机制是指CPU资源师被多个线程所共享,多个线程处于可运行状态,但是只允许一个线程在运行,他们通过竞争的方式抢占CPU.可以参考java 进程与线程的区别

 线程的状态:

  • 新生状态(New):当一个线程被创建一个线程实例后new Thread()或者new Thread(Runnable r),此线程处于新生状态,处于新生状态,线程有自己的内存空间,但该线程没有运行,此时该线程还不是活着的(not Alive)。
  • 就绪状态(Runnable):通过线程对象的start()方法启动线程使线程进入就绪状态(runnable),处于就绪状态的线程具备了运行条件(CPU执行资格),但是还没有抢到CPU执行权,不一定会被立即执行。此时线程在线程就绪队列中,等待系统为其分配CPU.等待状态不是执行状态,此时线程是活着的(isAlive=true).
  • 运行状态(Running):一旦线程抢到CPU执行权,线程进入运行状态(running),线程run方法才开始执行,运行状态的线程执行自己run方法里面的代码,直到调用其他方法而终止,或者等待某种资源而阻塞,或者完成任务而死亡;如果再给定的时间片内程序没有执行结束,就会被系统暂停当前正在运行的调度程序,回到线程的等待状态。此时线程是活着的(Alive)
  • 阻塞状态:(Blocked):通过调用join,sleep,wait或者资源被占用,使线程处于阻塞状态(blocked),处于阻塞状态的线程仍然活着。
  • 死亡状态:(Dead):当一个线程的run方法中的代码运行完毕,或被中断,或被异常退出,该线程处于死亡状态。一旦线程进入dead状态,它就再也不能进入一个独立线程的生命周期了,对一个处于dead状态的线程调用start方法,会出现runtime exception异常;处于dead状态的线程不是活着的(Alive)

 线程的方法和属性:

  • 优先级(priority):每一个线程都有一个优先级。默认优先级是5,优先级最高是10;优先级高的线程并不一定比优先级低的线程执行的机会高,只是执行的机率高;默认一个线程的优先级和创建他的线程优先级相同;setPriority(Thread.MAX_PRIORITY)方法来设置线程的优先级。
  • sleep(long millis)/sleep(long millis, int nanos)线程休眠:使当执行的线程休眠指定时间。作用:保持对象锁,让出CPU,调用目的是不让当前线程独自霸占该进程所获取的CPU资源,以留一定的时间给其他线程执行的机会;
  • Thread.yield():让出CPU的执行权,暂停当前执行的线程对象,让同等优先级的线程运行。稍微的释放执行权一会儿,时间不会很长。
  • Thread.join():用来临时加入线程执行,抢夺CPU执行权。例如:当A线程执行到B线程的Join方法时,A就会等待,等B线程执行完之后,A线程才会执行。
  • object.wait():用在同步中,如果不在锁中使用会抛出IllegalMonitorStateException异常。使线程处于阻塞状态,是线程进入等待池中,释放锁,释放执行权
  • object.notify()/notifyAll():唤醒在当前对象等待池中等待的第一个线程/所有线程。notify()/notifyAll()也必须拥有相同对象锁,否则也会抛出IllegalMonitorStateException异常。
  •   Synchronizing Block:机锁具有独占性、一旦被一个Thread持有,其他的Thread就不能再拥有(不能访问其他同步方法),方法一旦执行,就独占该锁,直到从该方法返回时才将锁释放,此后被阻塞的线程方能获得该锁,重新进入可执行状态。

下面给出上面方法的测试代码:

   yield(),join(),priority属性的测试,其它方法不测试了,在是我的文章里面可以看到:

设计两个线程,一个线程为主线程,一个线程Thread-0:

代码:没有用Join方法主线程和Thread-0交替的执行。大家都知道,这里不测试了。但是用了join方法大家看效果.

package com.lp.ecjtu.Thread;
/**
 *
 * @author Administrator
 * 当A线程执行到B线程的Join方法时,A就会等待,等B线程执行完之后,A线程才会执行
 * Join方法可以用来临时加入线程执行
 */
class Join implements Runnable{

    @Override
    public void run() {
        //Thread.yield();//暂停正在执行的先线程对象,并执行其它对象。稍微释放执行权一会儿
        for(int i=0;i<20;i++){
            //复写父类的toString方法, 返回该线程的字符串表示形式,包括线程名称、优先级和线程组。
            //Thread[Thread-1,5,main]默认的优先级为5,优先级从1-10
            System.out.println(Thread.currentThread().toString()+"-"+i);

        }
    }

}
public class JoinDemo {

    /**
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        Join join = new Join();
        Thread t1 = new Thread(join);
        Thread t2 = new Thread(join);
        //t1.setPriority(Thread.MAX_PRIORITY);//设置线程的优先级的方法
        t1.start();
        t2.join();//某个时刻join方法使t2临时加入线程,抢夺主线程的CPU权,直到t2执行完后,t1执行
        t2.start();

    }

}

输出结果:

Thread[Thread-0,5,main]-0
Thread[Thread-1,5,main]-0
Thread[Thread-1,5,main]-1
Thread[Thread-1,5,main]-2
Thread[Thread-1,5,main]-3
Thread[Thread-1,5,main]-4
Thread[Thread-1,5,main]-5
Thread[Thread-1,5,main]-6
Thread[Thread-1,5,main]-7
Thread[Thread-1,5,main]-8
Thread[Thread-1,5,main]-9
Thread[Thread-1,5,main]-10
Thread[Thread-1,5,main]-11
Thread[Thread-1,5,main]-12
Thread[Thread-1,5,main]-13
Thread[Thread-1,5,main]-14
Thread[Thread-1,5,main]-15
Thread[Thread-1,5,main]-16
Thread[Thread-1,5,main]-17
Thread[Thread-1,5,main]-18
Thread[Thread-1,5,main]-19
Thread[Thread-0,5,main]-1
Thread[Thread-0,5,main]-2
Thread[Thread-0,5,main]-3
Thread[Thread-0,5,main]-4
Thread[Thread-0,5,main]-5
Thread[Thread-0,5,main]-6
Thread[Thread-0,5,main]-7
Thread[Thread-0,5,main]-8
Thread[Thread-0,5,main]-9
Thread[Thread-0,5,main]-10
Thread[Thread-0,5,main]-11
Thread[Thread-0,5,main]-12
Thread[Thread-0,5,main]-13
Thread[Thread-0,5,main]-14
Thread[Thread-0,5,main]-15
Thread[Thread-0,5,main]-16
Thread[Thread-0,5,main]-17
Thread[Thread-0,5,main]-18
Thread[Thread-0,5,main]-19

可以看到蓝色的部分,某个时刻t2通过join方法强到执行权,执行完后,Thread-0执行。

例子2,优先级测试

package com.lp.ecjtu.Thread;
/**
 *
 * @author Administrator
 * 当A线程执行到B线程的Join方法时,A就会等待,等B线程执行完之后,A线程才会执行
 * Join方法可以用来临时加入线程执行
 */
class Join implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<20;i++){
            //复写父类的toString方法, 返回该线程的字符串表示形式,包括线程名称、优先级和线程组。
            //Thread[Thread-1,5,main]默认的优先级为5,优先级从1-10
            System.out.println(Thread.currentThread().toString()+"-"+i);

        }
    }

}
public class JoinDemo {

    /**
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        Join join = new Join();
        Thread t1 = new Thread(join);
        Thread t2 = new Thread(join);
        t2.setPriority(Thread.MAX_PRIORITY);//设置线程的优先级的方法
        t1.start();
        t2.start();

    }

}

输出结果:

Thread[Thread-1,10,main]-0
Thread[Thread-1,10,main]-1
Thread[Thread-1,10,main]-2
Thread[Thread-1,10,main]-3
Thread[Thread-1,10,main]-4
Thread[Thread-1,10,main]-5
Thread[Thread-1,10,main]-6
Thread[Thread-0,5,main]-0
Thread[Thread-1,10,main]-7
Thread[Thread-1,10,main]-8
Thread[Thread-0,5,main]-1
Thread[Thread-1,10,main]-9
Thread[Thread-1,10,main]-10
Thread[Thread-1,10,main]-11
Thread[Thread-1,10,main]-12
Thread[Thread-1,10,main]-13
Thread[Thread-1,10,main]-14
Thread[Thread-1,10,main]-15
Thread[Thread-1,10,main]-16
Thread[Thread-1,10,main]-17
Thread[Thread-1,10,main]-18
Thread[Thread-0,5,main]-2
Thread[Thread-1,10,main]-19
Thread[Thread-0,5,main]-3
Thread[Thread-0,5,main]-4
Thread[Thread-0,5,main]-5
Thread[Thread-0,5,main]-6
Thread[Thread-0,5,main]-7
Thread[Thread-0,5,main]-8
Thread[Thread-0,5,main]-9
Thread[Thread-0,5,main]-10
Thread[Thread-0,5,main]-11
Thread[Thread-0,5,main]-12
Thread[Thread-0,5,main]-13
Thread[Thread-0,5,main]-14
Thread[Thread-0,5,main]-15
Thread[Thread-0,5,main]-16
Thread[Thread-0,5,main]-17
Thread[Thread-0,5,main]-18
Thread[Thread-0,5,main]-19

总结:从结果可以看出Thread-1,10,main优先级为10的线程2先执行。

yield方法是正在执行的线程释放执行权,暂停执行一小会儿。这里不测了。。。。。。

时间: 2024-10-08 08:57:04

java基础知识回顾之java Thread类学习(十)--线程的状态以及转化使用的方法介绍的相关文章

java基础知识回顾之java Thread类学习(八)--java多线程通信等待唤醒机制经典应用(生产者消费者)

 *java多线程--等待唤醒机制:经典的体现"生产者和消费者模型 *对于此模型,应该明确以下几点: *1.生产者仅仅在仓库未满的时候生产,仓库满了则停止生产. *2.消费者仅仅在有产品的时候才能消费,仓空则等待. *3.当消费者发现仓储没有产品可消费的时候,会唤醒等待生产者生产. *4.生产者在生产出可以消费的产品的时候,应该通知等待的消费者去消费. 下面先介绍个简单的生产者消费者例子:本例只适用于两个线程,一个线程生产,一个线程负责消费. 生产一个资源,就得消费一个资源. 代码如下: pub

java基础知识回顾之java Thread类学习(七)--java多线程通信等待唤醒机制(wait和notify,notifyAll)

1.wait和notify,notifyAll: wait和notify,notifyAll是Object类方法,因为等待和唤醒必须是同一个锁,不可以对不同锁中的线程进行唤醒,而锁可以是任意对象,所以可以被任意对象调用的方法,定义在Object基类中. wait()方法:对此对象调用wait方法导致本线程放弃对象锁,让线程处于冻结状态,进入等待线程的线程池当中.wait是指已经进入同步锁的线程,让自己暂时让出同步锁,以便使其他正在等待此锁的线程可以进入同步锁并运行,只有其它线程调用notify方

java基础知识回顾之java Thread类学习(六)--java多线程同步函数用的锁

1.验证同步函数使用的锁----普通方法使用的锁 思路:创建两个线程,同时操作同一个资源,还是用卖票的例子来验证.创建好两个线程t1,t2,t1线程走同步代码块操作tickets,t2,线程走同步函数封装的代码操作tickets,同步代码块中的锁我们可以指定.假设我们事先不知道同步函数用的是什么锁:如果在同步代码块中指定的某个锁(测试)和同步函数用的锁相同,就不会出现线程安全问题,如果锁不相同,就会发生线程安全问题. 看下面的代码:t1线程用的同步锁是obj,t2线程在操作同步函数的资源,假设不

java基础知识回顾之java Thread类学习(五)--java多线程安全问题(锁)同步的前提

这里举个例子讲解,同步synchronized在什么地方加,以及同步的前提: * 1.必须要有两个以上的线程,才需要同步. * 2.必须是多个线程使用同一个锁. * 3.必须保证同步中只能有一个线程在运行,锁加在哪一块代码 那么我们要思考的地方有:1.知道我们写的哪些是多线程代码 2.明确共享数据 3.明确多线程运行的代码中哪些语句是操作共享数据的.. 4.要确保使用同一个锁. 下面的代码:需求:两个存户分别往银行存钱,每次村100块,分三次存完. class bank{ private int

java基础知识回顾之java Thread类学习(四)--java多线程安全问题(锁)

上一节售票系统中我们发现,打印出了错票,0,-1,出现了多线程安全问题.我们分析为什么会发生多线程安全问题? 看下面线程的主要代码: @Override public void run() { // TODO Auto-generated method stub while(true){ if(ticket > 0){//当线程0被调起的时候,当执行到这条判断语句的时候,线程1被调起抢了CPU资源,线程0进入冻结状态. try { Thread.sleep(100);//中断当前活跃的线程,或者

java基础知识回顾之java Thread类学习(把)--java.util.concurrent.locks(JDK1.5)与synchronized异同讲解

看API文档介绍几个方法:  JDK1.5中提供了多线程的升级解决方案: 特点: 1.将同步synchronized显示的替换成Lock                    2.接口Condition:Condition替代了Object监视器方法(wait.notify.notifyAll),分别替换成了await(),signal() (唤醒一个等待线               程),signalAll() 唤醒多个线程.一个锁可以绑定多个condition对象,可以对应好几组wait,

java基础知识回顾之java Thread类学习(七)--java多线程安全问题(死锁)

死锁:是两个或者两个以上的线程被无限的阻塞,线程之间互相等待所需资源. 线程死锁产生的条件: 当两个线程相互调用Join()方法. 当两个线程使用嵌套的同步代码块的时候,一个线程占用了另一个线程的锁,互相等待阻塞,就有可能产生死锁. 下面看代码: 代码1:死锁的案例 package com.lp.ecjtu.Thread; /* 死锁:常见情景之一:同步的嵌套. */ class Ticket implements Runnable { private int num = 100; Object

java基础知识回顾之java Thread类学习(九)--wait和notify区别

wait和sleep区别:  相同点:调用wait,sleep方法都可以是线程进入阻塞状态,让出cpu的执行权. 不同点:1.sleep必须指定时间,但是wait方法可以指定时间,也可以不指定时间. 2.wait方法必须在同步中使用,但是sleep不一定在同步中使用. 3.在同步中,调用sleep方法释放CPU执行权,但是不会释放锁,即使让出了CPU执行权,其它线程也无法进入同步锁,不能得到执行.但是wait  方法不仅释放CPU执行权,而且释放同步锁,进入阻塞状态.也就是说其它等待此锁的线程可

java基础知识回顾之java Thread类学习(三)--java线程实现常见的两种方式实现好处:

总结:实现Runnable接口比继承Thread类更有优势: 1.因为java只能单继承,实现Runnable接口可以避免单继承的局限性 2.继承Thread类,多个线程不能处理或者共享同一个资源,但是实现Runnable接口可以处理同一个资源. 下面我们做个测试:验证下.车站的售票系统售票的例子,车站的各个售票口相当于各个线程,我们先使用第一种方法几继承Thread类的方式实现: 代码如下: package com.lp.ecjtu.Thread; /** * * @author Admini

java基础知识回顾之---java String final类之intern方法

public class StringObjectDemo { /** * @param args */ public static void main(String[] args) { String hello = "Hello", lo = "lo"; System.out.print((hello == "Hello") + " ");//true System.out.print((Other.hello == hel