Java线程的六种状态以及切换

时间  2020-12-06
标签 java 多线程 并发 ide 函数 工具 性能 this spa 线程 栏目 Java 繁體版
原文   原文链接

Thread线程状态的划分:

Java中线程的状态分为6种。java

  1. 初始(NEW)：新建立了一个线程对象，但尚未调用start()方法。
  2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象建立后，其余线程(好比main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在得到CPU时间片后变为运行中状态（running）。

3. 阻塞(BLOCKED)：表示线程阻塞于锁。
4. 等待(WAITING)：进入该状态的线程须要等待其余线程作出一些特定动做（通知或中断）。
5. 超时等待(TIMED_WAITING)：该状态不一样于WAITING，它能够在指定的时间后自行返回。多线程

  1. 终止(TERMINATED)：表示该线程已经执行完毕。

这6种状态定义在Thread类的State枚举中，可查看源码进行一一对应。并发

1、线程的状态图

线程状态图

2、状态详细说明

2.1. 初始状态(NEW)

实现Runnable接口和继承Thread能够获得一个线程类，new一个实例出来，线程就进入了初始状态。ide

2.2. 就绪状态(RUNNABLE之READY)

  1. 就绪状态只是说你资格运行，调度程序(Cpu)没有挑选到你，你就永远是就绪状态。
  2. 调用线程的start()方法，此线程进入就绪状态。
  3. 当前线程sleep()方法结束，其余线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。
  4. 当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
  5. 锁池里的线程拿到对象锁后，进入就绪状态。

2.3. 运行中状态(RUNNABLE之RUNNING)

线程调度程序从可运行池中选择一个线程做为当前线程时线程所处的状态。这也是线程进入运行状态的惟一的一种方式。函数

2.4. 阻塞状态(BLOCKED)

阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。工具

2.5. 等待(WAITING)

处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，不然会处于无限期等待的状态。性能

2.6. 超时等待(TIMED_WAITING)

处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其余线程显示地唤醒，在达到必定时间后它们会自动唤醒。this

2.7. 终止状态(TERMINATED)

  1. 当线程的run()方法完成时，或者主线程的main()方法完成时，咱们就认为它终止了。这个线程对象也许是活的，可是它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。
  2. 在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

3、等待队列

  • 调用obj的wait(), notify()方法前，必须得到obj锁，也就是必须写在synchronized(obj) 代码段内。
  • 与等待队列相关的步骤和图

  1. 线程1获取对象A的锁，正在使用对象A。
  2. 线程1调用对象A的wait()方法。
  3. 线程1释放对象A的锁，并立刻进入等待队列。
  4. 锁池里面的对象争抢对象A的锁。
  5. 线程5得到对象A的锁，进入synchronized块，使用对象A。
  6. 线程5调用对象A的notifyAll()方法，唤醒全部线程，全部线程进入同步队列。若线程5调用对象A的notify()方法，则唤醒一个线程，不知道会唤醒谁，被唤醒的那个线程进入同步队列。
  7. notifyAll()方法所在synchronized结束，线程5释放对象A的锁。
  8. 同步队列的线程争抢对象锁，但线程1何时能抢到就不知道了。 

4、同步队列状态

  • 当前线程想调用对象A的同步方法时，发现对象A的锁被别的线程占有，此时当前线程进入同步队列。简言之，同步队列里面放的都是想争夺对象锁的线程。
  • 当一个线程1被另一个线程2唤醒时，1线程进入同步队列，去争夺对象锁。
  • 同步队列是在同步的环境下才有的概念，一个对象对应一个同步队列。
  • 线程等待时间到了或被notify/notifyAll唤醒后，会进入同步队列竞争锁，若是得到锁，进入RUNNABLE状态，不然进入BLOCKED状态等待获取锁。
    image.png

5、几个方法的比较

  1. Thread.sleep(long millis)，必定是当前线程调用此方法，当前线程进入TIMED_WAITING状态，但不释放对象锁，millis后线程自动苏醒进入就绪状态。做用：给其它线程执行机会的最佳方式。
  2. Thread.yield()，必定是当前线程调用此方法，当前线程放弃获取的CPU时间片，但不释放锁资源，由运行状态变为就绪状态，让OS再次选择线程。 做用：让相同优先级的线程轮流执行，但并不保证必定会轮流执行。实际中没法保证yield()达到让步目的，由于让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会致使阻塞。该方法与sleep()相似，只是不能由用户指定暂停多长时间。
  3. thread.join()/thread.join(long millis)，当前线程里调用其它线程t的join方法，当前线程进入WAITING/TIMED_WAITING状态，当前线程不会释放已经持有的对象锁。线程t执行完毕或者millis时间到，当前线程通常状况下进入RUNNABLE状态，也有可能进入BLOCKED状态（由于join是基于wait实现的）。
  4. Object.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout) timeout时间到自动唤醒。
  5. Object.notify()唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的全部线程。
  6. LockSupport.park()/LockSupport.parkNanos(long nanos),LockSupport.parkUntil(long deadlines), 当前线程进入WAITING/TIMED_WAITING状态。对比wait方法,不须要得到锁就可让线程进入WAITING/TIMED_WAITING状态，须要经过LockSupport.unpark(Thread thread)唤醒。

六 建立线程的几种方式

Thread

线程运行的过程会产生不少信息，这些信息都保存在Thread类中的成员变量里面，常见的有：
a.线程的ID是惟一标识getId()
b.线程的名称：getName()，若是不设置线程名称默认为“Thread-xx”
c.线程的优先级：getPriority，线程优先级从1-10,其中数字越大表示优先级别越高，同时得到JVM调度执行的可能性越大，JDK内置了三种常见的状态：spa

`//最小优先级
public final static int MIN_PRIORITY = 1;

//通常优先级
public final static int NORM_PRIORITY = 5;

//最大优先级
public final static int MAX_PRIORITY = 10;`

通常不推荐设置线程的优先级，若是进行设置了非法的优先级程序就会出现IllegalArgumentException异常。线程

建立线程方式一：

继承Thread类。
步骤：
1，定义一个类继承Thread类。
2，覆盖Thread类中的run方法。
3，直接建立Thread的子类对象建立线程。
4，调用start方法开启线程并调用线程的任务run方法执行。

能够经过Thread的getName获取线程的名称 Thread-编号(从0开始)
主线程的名字就是main。

class Demo extends Thread
{
    /**
     *线程名称
     */
    private String name;
    Demo(String name)
    {
       //父类构造函数，改线程的名称 
        super(name); 
        //this.name = name;
    }
    //***run方法中定义就是线程要运行的任务代码。***
    public void run()
    {
        for(int x=0; x<10; x++)
        {
            //for(int y=-9999999; y<999999999; y++){}
            System.out.println(name+"....x="+x+".....name="+Thread.currentThread().getName());
        }
    }
}

class ThreadDemo2 
{
    public static void main(String[] args) 
    {
        Demo d1 = new Demo("旺财");
        Demo d2 = new Demo("xiaoqiang");
        d1.start();//开启线程，调用run方法。
        d2.start();
        System.out.println("over...."+Thread.currentThread().getName());
    }
}

建立线程方式二

当该类有本身父类的时候，经过实现Runnable接口，覆盖run方法。（经常使用）
步骤：

1，定义类实现Runnable接口。

2，覆盖接口中的run方法，将线程的任务代码封装到run方法中。

3，经过Thread类建立线程对象，并将Runnable接口的子类对象做为Thread类的构造函数的参数进行传递。

为何？由于线程的任务都封装在Runnable接口子类对象的run方法中。

因此要在线程对象建立时就必须明确要运行的任务。

思想：将线程的任务经过Runnable接口封装成了对象。

4，调用线程对象的start方法开启线程。

实现Runnable接口的好处：

1，将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成对象。
2，避免了java单继承的局限性。

//extends Fu 
//准备扩展Demo类的功能，让其中的内容能够做为线程的任务执行。
//经过接口的形式完成。
class Demo implements Runnable{
    public void run()
    {
        show();
    }
    public void show()
    {
        for(int x=0; x<20; x++)
        {
            System.out.println(Thread.currentThread().getName()+"....."+x);
        }
    }
}

class  ThreadDemo
{
    public static void main(String[] args) 
    {    
        Demo d = new Demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        t1.start();
        t2.start();

    }
}

建立线程方式三

实现Callable接口

与使用Runnable相比， Callable功能更强大些

  1 相比run()方法，能够有返回值

  2 方法能够抛出异常 

  3 支持泛型的返回值 

  4 须要借助FutureTask类，好比获取返回结果

Future接口

 1  能够对具体Runnable、Callable任务的执行结果进行取消、查询是
否完成、获取结果等。

 2  FutrueTask是Futrue接口的惟一的实现类

3   FutureTask 同时实现了Runnable, Future接口。它既能够做为 Runnable被线程执行，又能够做为Future获得Callable的返回值

//1.建立一个实现Callable的实现类
class Stu implements Callable {
    //2.实现call方法,将此线程须要执行的操做生命call()中
    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 1; i <=100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class Bank {
    public static void main(String[] args) {
        //3.建立Callable接口实现类的对象
        Stu stu = new Stu();
        //4.将此Callable接口实现类的对象做为传递到FutureTask构造器中，建立FutureTask的对象
         FutureTask futureTask = new FutureTask(stu);
        //5.FutureTask的对象做为参数传递到Thread类的构造器中建立Thread，并调用start()
         new Thread(futureTask).start();
        try {
            Object sum = futureTask.get();
            System.out.println("总和为"+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

建立线程方式四

使用线程池
背景：常常建立和销毁、使用量特别大的资源，好比并发状况下的线程， 对性能影响很大。

思路：提早建立好多个线程，放入线程池中，使用时直接获取，使用完 放回池中。能够避免频繁建立销毁、实现重复利用。相似生活中的公共交 通工具。

好处:

1提升响应速度（减小了建立新线程的时间）;

2下降资源消耗（重复利用线程池中线程，不须要每次都建立）;

3便于线程管理;

corePoolSize：核心池的大小

 maximumPoolSize：最大线程数

 keepAliveTime：线程没有任务时最多保持多长时间后会终止
//建立并使用多线程的第四种方法：使用线程池
class MyThread implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if(i % 2 ==0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }

}

public class ThreadPool {
    public static void main(String[] args) {
        // 1.提供指定线程的数量
        ExecutorService service = Executors.newFixedThreadPool(10);
        //设置线程的属性
        ThreadPoolExecutor service1= (ThreadPoolExecutor) service;
        //service1.setMaximumPoolSize(15);
        //service1.setCorePoolSize();*/
        // 2.将Runnable实现类的对象做为形参传递给ExecutorService的submit()方法中，开启线程
        // 并执行相关的run()
        service.execute(new MyThread());//适用于Runnable
        //service.submit();适用于Callable

        // 3.结束线程的使用
        service.shutdown();

    }
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程