Java并发编程（二）—— 线程的状态

已于 2023-03-14 14:27:23 修改
阅读量1.6k 收藏 2
点赞数
文章标签： 服务器 网络 java
于 2022-03-05 15:47:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingyu19911016/article/details/123295961
版权

1 线程的状态

线程的六个状态：创建、就绪、运行、等待/超时等待、阻塞以及死亡：

  • 创建状态（NEW）：生成线程对象之后，调用start()方法之前，线程处于创建状态；
  • 就绪状态（READY）：线程对象调用了start()方法之后，就进入了就绪状态，但是还要和其它线程竞争 CPU，只有获得了 CPU 才可以执行任务。另外，在线程运行之后，从等待或者睡眠中被激活之后，也会处于就绪状态；
  • 运行状态（RUNNABLE）：处于就绪状态的线程得到 CPU 时间片之后，就会进入运行状态，开始执行 run() 方法当中的代码； 运行状态和就绪状态可以通过系统调度完成状态改变，运行状态的代码可以调用yield()方法，转为就绪状态。
  • 等待状态（WAITING）：调用 wait() 方法，线程进入等待状态。一个处于等待状态的线程正在等待另一个线程执行某个特定的动作。用 notify()/notifyAll() 方法会唤醒线程，使线程从等待状态进入就绪状态或者运行状态。等待状态是没有时间戳的，如果没有被唤醒，会一直等待下去。
  • 超时等待状态（主动进入）（TIMED_WAITING）：可以限定等待时间 — wait(time)，如果时间到了，即便是没有被唤醒，也会从等待状态恢复到就绪状态或运行状态。调用 sleep(time) 会进入计时等待状态（等待的线程主动释放 CPU，wait释放锁，sleep不释放锁）
  • 阻塞状态（被动进入）（BLOCKED）：正在运行的线程因为某些原因被剥夺了 CPU，比如说，该线程试图得到一个锁，而该锁正在被其它线程持有，没能拿到锁，就会进入阻塞状态，重新获取到锁，就会进入就绪状态，可以去和其它线程竞争 CPU；（阻塞状态的线程会被剥夺 CPU，不会释放锁，线程仍然处于内存中）
  • 死亡状态（TERMINATED）：如果一个线程的run()方法执行结束或者调用stop()方法后，该线程就会死亡。对于已经死亡的线程，就无法再使用start()方法令其进入就绪；
// Thread.java
public enum State {
    NEW, // 线程已创建，但还没有start
    RUNNABLE, // 处于可运行状态，一切就绪
    BLOCKED, // 处于阻塞状态，比如等待某个锁的释放
    WAITING, // 处于等待状态
    TIMED_WAITING, // 超时等待状态
    TERMINATED; // 终止运行
}

Java线程状态变迁如图所示：

线程的生命周期

从图中可以看到，线程创建之后，调用start()方法开始运行。当线程执行wait()方法之 后，线程进入等待状态。进入等待状态的线程需要依靠其它线程的通知才能够返回到运行状态，而超时等待状态相当于在等待状态的基础上增加了超时限制，也就是超时时间到达时将会返回到运行状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到阻塞状态。线程在执行完Runnable.run()的方法之后将会进入到终止状态。

注意：Java将操作系统中的运行和就绪两个状态合并称为运行状态。阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块（获取锁）时的状态，但是阻塞在java.concurrent包中Lock接口的线程状态却是等待状态，因为java.concurrent包中Lock接口对于阻塞的实现均使用了LockSupport类中的相关方法。

挂起（等待，阻塞）进程在操作系统中可以定义为暂时被淘汰出内存的进程，机器的资源是有限的，在资源不足的情况下，操作系统对在内存中的程序进行合理的安排，其中有的进程被暂时调离出内存，当条件允许的时候，会被操作系统再次调回内存，重新进入等待被执行的状态即就绪态。

2 Android 中的线程类 Thread

public class Thread implements Runnable {
  	...
}

public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

通过以上代码可以知道 Thread 继承了 Runnable，侧面说明线程是”可执行代码“。 Runnable 是一个接口类，提供了唯一的方法 run()。

2.1 相关属性
public class Thread implements Runnable {
    /*
     * Thread ID
     */
    private final long tid;
  
  	/* For generating thread ID 全局变量，默认值是 0 */
    private static long threadSeqNumber;
  
  	/*
  	 * 线程名
  	 */
  	private volatile String name;
  
  	public Thread(Runnable target) {
        this(null, target, "Thread-" + nextThreadNum(), 0); // 1
    }
  
  	private Thread(ThreadGroup g, Runnable target, String name,
                   long stackSize, AccessControlContext acc,
                   boolean inheritThreadLocals) {
      	if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name; // 2
       	...
        /* Set thread ID */
        this.tid = nextThreadID(); // 3
    }
  
  	private static synchronized long nextThreadID() {
        return ++threadSeqNumber;
    }
  
  	public long getId() {
        return tid;
    }
  
}

通过注释 1 处可以知道，在创建 Thread 实例时，如果未显示设置线程名称，则默认线程名称为 Thread- 加上一个递增的数值 threadSeqNumber。threadSeqNumber 在每次调用 new Thread(...) 时是自动递增的，其作用只是对于未显示配置线程名的线程在 name 上做一个简单的区分。注意，这里并不是真正的线程 ID，在 Logcat 中打印的 getId() 也不是这个 ID，而是 Dalvik 中的线程 ID。

public class Thread implements Runnable {		
    	private int priority;

      /**
       * The minimum priority that a thread can have. 最低优先级
       */
      public static final int MIN_PRIORITY = 1;

     /**
       * The default priority that is assigned to a thread. 默认优先级
       */
      public static final int NORM_PRIORITY = 5;

      /**
       * The maximum priority that a thread can have. 最高优先级
       */
      public static final int MAX_PRIORITY = 10;
  
  		public String toString() {
        ThreadGroup group = getThreadGroup();
        if (group != null) {
            return "Thread[" + getName() + "," + getPriority() + "," +
                           group.getName() + "]";
        } else {
            return "Thread[" + getName() + "," + getPriority() + "," +
                            "" + "]";
        }
    }
}

线程调度器会根据 priority 来决定优先运行哪个线程（不保证）。Thread 中定义了三个优先级常量 1、5、10，默认是 5。 可以通过以下代码进行验证：

public class Test {
    public static void main(String[] args) {
        Thread mt = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("running");
            }
        });
        mt.start();
        System.out.println(mt);
        System.out.println("thread id: " + mt.getId());
        System.out.println("thread name: " + mt.getName());
    }

}

// running
// Thread[Thread-0,5,main]
// thread id: 13
// thread name: Thread-0

守护线程还是用户线程：

public class Thread implements Runnable {
  	
  	/**
  	 * Whether or not the thread is a daemon thread.
  	 * 当前线程是否是守护线程
  	 */
  	private boolean daemon = false; 
  
  	/**
  	 * 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.
  	 * 线程栈大小，默认是 0。即使使用默认的线程栈大小（由 Dalvik 中的全局变量 gDvm.stackDize 决定）
  	 */
  	private long stackSize;
  	
   	/**
   	 * What will be run.
   	 * 一个 Runnable 对象，Thread.run() 方法中会调用 target.run() 方法，这是线程真正处理事务的地方
   	 */
  	private Runnable target;
  
  	public final void setDaemon(boolean on) {
        checkAccess();
        if (isAlive()) {
            throw new IllegalThreadStateException();
        }
        daemon = on;
    }
}

可以通过 setDaemon(true) 把线程设置为守护线程。 守护线程通常用于执行不重要的工作，比如监控其他线程的运行情况。GC 线程就是守护线程。setDaemon(...) 要在线程启动前设置，否则 JVM 会抛出非法线程状态。

Daemon 线程用作完成支持性工作，但在 Java 虚拟机退出时，Daemon 线程中的 finally 块不一定会执行：

public class Test {
    public static void main(String[] args) {
        Thread thread = new Thread(new DaemonRunnable(), "daemonRunner");
        thread.setDaemon(true);
        thread.start();
    }

    static class DaemonRunnable implements Runnable {
        @Override
        public void run() {
            try {
                Thread.sleep(10 * 1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                System.out.println("daemon thread finally run");
            }
        }
    }
}

运行程序，在终端或者命令提示符上没有任何输出。主线程在启动了线程 thread 后，随着 main(...) 方法执行完毕，Daemon 线程也需要终止，因此 finally 块中的代码并没有执行。因此，在构建 Daemon 线程时，不能依靠 finally 块中的内容来确保关闭或清理资源。

总结：

  • id：线程id用于标识不同的线程，id 可能被后续创建的线程使用，是只读属性，不能修改；
  • name：线程的名称，默认值是Thread-(id)；
  • daemon：是守护线程还是用户线程，可以通过setDaemon(true)把线程设置为守护线程。守护线程通常用于执行不重要的任务，比如监控其他线程的运行情况，GC线程就是一个守护线程。 setDaemon()要在线程启动前设置，否则JVM会抛出非法线程状态异常，可被继承。
  • priority：线程调度器会根据这个值来决定优先运行哪个线程（不保证），优先级的取值范围为1~10，默认值是 5，可被继承。Thread中定义了下面三个优先级常量：
    • 最低优先级：MIN_PRIORITY = 1；
    • 默认优先级：NORM_PRIORITY = 5；
    • 最高优先级：MAX_PRIORITY = 10；
2.2 常用方法

Thread 的常用方法

2.2.1 thread.start()方法和thread.run()方法

thread.start() 方法可以使线程从创建状态转为就绪状态，如果可以获得 CPU，则进入运行状态。thread.run() 方法中是线程启动之后需要执行的代码。

public class Thread implements Runnable {

  	public synchronized void start() {
        if (started)
            throw new IllegalThreadStateException();

        group.add(this);

        started = false;
        try {
            nativeCreate(this, stackSize, daemon);
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
             
            }
        }
    }


    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}
2.2.2 thread.interrupt()、Thread.interrupted()方法和Thread.isInterrupted()方法的区别？

thread.interrupt() 的作用是中断此线程（此线程不一定是当前线程，而是指调用该方法的 Thread 实例所代表的线程），但实际上只是给线程设置一个中断标志，线程仍会继续运行。

Thread.interrupted() 的作用是测试当前线程是否被中断（检查中断标志），返回一个 boolean 类型的值并清除中断状态，当再次调用此方法时中断状态已经被清除，将返回一个 false。

Thread.isInterrupted() 的作用是只测试此线程是否被中断 ，不清除中断状态。

2.2.3 为什么Thread.stop()和Thread.suspend()方法不推荐使用？

当调用 Thread.stop() 方法时会发生两件事：

  • 即刻停止 run() 方法中剩余的全部工作，包括在 catch 或 finally 语句，并抛出 ThreadDeath 异常（通常情况下此异常不需要显示的捕获），因此可能会导致一些清理性的工作的得不到完成，如文件，数据库等的关闭；
  • 会立即释放该线程所持有的所有的锁，导致数据得不到同步的处理，出现数据不一致的问题；
class Test {

    public static void main(String[] args) throws Exception {
        TestObject testObject = new TestObject();
        Thread t1 = new Thread(() -> {
            try {
                testObject.print("1", "2");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t1.start();
        Thread.sleep(1000);
        t1.stop();
        System.out.println("first: " + testObject.getFirst() + " second: " + testObject.getSecond());
    }

}

class TestObject {
    private String first = "ja";
    private String second = "va";

    public synchronized void print(String first, String second) throws InterruptedException {
        this.first = first;
        Thread.sleep(10_000);
        this.second = second;
    }

    public String getFirst() {
        return first;
    }

    public String getSecond() {
        return second;
    }
}

// first: 1 second: va

Thread.suspend()和Thread.resume()必须要成对出现，否则非常容易发生死锁。这两个操作就好比播放器的暂停和恢复。

不推荐使用 suspend() 去挂起线程的原因，是因为 suspend() 在导致线程暂停的同时，并不会去释放任何锁资源，其它线程就无法访问被它占用的锁，直到对应的线程执行 resume() 方法后，被挂起的线程才能继续，从而其它被阻塞在这个锁的线程才可以继续执行。 但是，如果Thread.resume()操作出现在Thread.suspend()之前执行，那么线程将一直处于挂起状态，同时一直占用锁，这就产生了死锁。

class Test {

    public static void main(String[] args) throws Exception {
        TestObject testObject = new TestObject();
        
        Thread t1 = new Thread(() -> testObject.print());
        t1.setName("A");
        t1.start();
        Thread.sleep(1000);

        Thread t2 = new Thread(() -> {
            System.out.println("B线程已启动，但无法进行print方法");
            testObject.print();
        });
        t2.setName("B");
        t2.start();
    }

}

class TestObject {

    public synchronized void print() {
        if (Thread.currentThread().getName().equals("A")) {
            System.out.println("A线程独占资源了");
            Thread.currentThread().suspend();
        }
    }

}

// A线程独占资源了
// B线程已启动，但无法进行print方法
2.2.4 如何停止一个正在运行的线程？

使用 thread.interrupt() 产生打断标志位来停止线程。

方案一：捕捉打断标记并且直接 return：

class Test {

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        try {
            Thread.sleep(200);
            thread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static class MyThread extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 50_000; i++) {
                if (this.isInterrupted()) {
                    System.out.println("线程终止，停止for循环。");
                    return;
                }
                System.out.println("i = " + (i + 1));
            }
        }
    }

}

方案二：捕捉打断标记，并且抛出异常终止程序

class Test {

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        try {
            Thread.sleep(200);
            thread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static class MyThread extends Thread {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 100_000; i++) {
                    if (this.isInterrupted()) {
                        System.out.println("线程终止，停止for循环。");
                        throw new InterruptedException();
                    }
                    System.out.println("i = " + (i + 1));
                }
            } catch (InterruptedException e) {
                System.out.println("MyThread抛出InterruptedException。");
                e.printStackTrace();
            }
        }
    }

}

方案三：当线程处于sleep、park、join、wait的时候需要在catch块处理异常时自行设置打断标记

当线程处于正常状态的时候，打断会产生打断的标记位，但是在线程处于sleep、park、join、wait等状态时，被打断将不会产生标记位，可以使用try，catch来处理该情况，当程序被打断时，在程序catch并处理打断异常时候可以自己添加打断标记，从而设置打断标记。（两阶段终止模式）：

class Test {

    public static void main(String[] args) throws InterruptedException {
        TwoParseTermination twoParseTermination = new TwoParseTermination();
        twoParseTermination.start();
        Thread.sleep(3000);
        twoParseTermination.stop();
    }
}

class TwoParseTermination {
    Thread thread;

    public void start() {
        thread = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("线程结束，正在收尾...");
                    break;
                }
                try {
                    Thread.sleep(500);
                    System.out.println("正在执行监控的功能");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    e.printStackTrace();
                }
            }
        });
        thread.start();
    }

    public void stop() {
        thread.interrupt();
    }
}
2.2.5 Thread.sleep(long millis)和Thread.yield()的区别？

状态的区别：

  • 调用 Thread.sleep(long millis) 会让当前线程从 RUNNABLE 进入 TIMED_WAITING 状态；
  • 调用Thread.yield()会让当前线程放弃 CPU，调度执行其它线程；

调度的区别：

  • 调用 Thread.sleep(long millis) 之后，该线程将进入超时等待状态，分不到CPU的时间片；
  • 调用 Thread.yield() 之后，该线程会让出 CPU 的使用权，但是任务调度器仍然可能分配给该线程时间片，从宏观上只是该线程被分配 CPU 的概率变低了；
public class Thread implements Runnable {
  
  public static void sleep(long millis) throws InterruptedException {
    sleep(millis, 0);
  }
  
  public static native void yield();
}
2.2.6 为什么 Thread.sleep(long millis) 和 Thread.yield() 是类方法，而 thread.wait() 和 thread.join() 是成员方法？

Thread.sleep(long millis) 和 Thread.yield() 方法在当前正在执行的线程上运行，在其它线程上调用这些方法是没有意义的。也就是说只有本线程才能执行休眠操作，如果 Thread.sleep(long millis) 是成员方法，其它线程可以获得该线程的实例化对象，从而让当前线程强制休眠（释放 CPU 的资源），这样会带来不可预估的后果。因此，Thread.sleep(long millis) 和 Thread.yield() 不可以被其他线程调用，只能被自身线程调用，也是就是必须是自愿才可以。

对于 object.wait() 和 thread.join()，object.wait() 是本线程获取锁之后，锁对象调用的 wait() 方法，实际上还是在本线程中使用，thread.join() 在其它线程中调用，因为其本身设计的意义就是其它线程等待该线程完成。

2.2.7 有三个线程T1、T2、T3，如何保证顺序执行？

确保一个线程启动之后等待他执行完再进行下一个：

t1.start();
t1.join();
t2.start();
t2.join();
t3.start();
t3.join();
2.2.8 Java 中守护线程和本地线程区别？

Java 中的线程分为两种：守护线程（Daemon）和用户线程（User）。任何线程都可以设置为守护线程和用户线程，通过方法Thread.setDaemon(boolean on)，true 则把该线程设置为守护线程，默认用户线程。Thread.setDaemon() 必须在 Thread.start() 之前调用，否则运行时会抛出异常。

守护线程的特点是，如果一个进程中的其它用户线程全部运行完毕，那么这时守护线程也会自动结束，比如JVM的垃圾回收线程是一个守护线程，当所有线程已经撤离，不再产生垃圾，守护线程自然就没有任务了。

2.2.9 Thread.sleep(long millis) 和 object.wait() 有什么区别？

Thread.sleep(long millis)是Thread类的静态方法，在线程使用Thread.sleep(long millis)方法之后会让出 CPU 的资源，但是不会释放锁资源。

object.wait() 方法是 Object 的方法，只能在同步代码块中被调用，某个线程使用锁对象的 wait 方法，会释放掉该线程的锁资源，同时还有 CPU 使用权，让其它线程去竞争。

Thread.sleep(0) 有什么作用？触发操作系统立刻重新进行一次 CPU 竞争，竞争的结果可能是当前线程仍然获得 CPU 控制权，也可能是别的线程获得 CPU 控制权。

通过以下代码运行时的线程信息，更加深入地理解线程状态：

public class ThreadState {

  public static void main(String[] args) {
    new Thread(new TimeWaiting(), "TimeWaitingThread").start();
    new Thread(new Waiting(), "WaitingThread").start();
    // 使用两个Blocked线程，一个获取锁成功，另一个被阻塞
    new Thread(new Blocked(), "BlockedThread-1").start();
    new Thread(new Blocked(), "BlockedThread-2").start();
  }

  // 该线程不断地进行睡眠
  static class TimeWaiting implements Runnable {
    @Override
    public void run() {
      while (true) {
        SleepUtils.second(100);
      }
    }
  }

  // 该线程在Waiting.class实例上等待
  static class Waiting implements Runnable {
    @Override
    public void run() {
      while (true) {
        synchronized (Waiting.class) {
          try {
            Waiting.class.wait();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }
    }
  }

  // 该线程在Blocked.class实例上加锁后，不会释放该锁
  static class Blocked implements Runnable {
    @Override
    public void run() {
      synchronized (Blocked.class) {
        while (true) {
          SleepUtils.second(100);
        }
      }
    }
  }
}

class SleepUtils {
  public static final void second(long seconds) {
    try {
      TimeUnit.SECONDS.sleep(seconds);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

参考

（进程/线程）阻塞、挂起、睡眠的区别
挂起和阻塞区别以及sleep和wait的区别
理解线程的挂起、阻塞 和 sleep（转载）
java 多线程 面试题整理(更新…)
线程常用的方法
线程常见的几种方法
#java 常见线程方法
进程的执行和挂起
线程的状态是怎么进行划分的？
Thread中stop(),suspend(),resume()为什么不安全
Thread类中interrupt（）、interrupted（）和isInterrupted（）方法详解
Android虚拟机线程启动过程解析, 获取Java线程真实线程Id的方式

橙子19911016
关注
Java并发基础---线程的状态
joy_pan的博客
10-27 167
线程的状态 参考源码： public enum State { /** * Thread state for a thread which has not yet started. */ NEW, /** * Thread state for a runnable thread. A th...
Java多线程与并发 --- 线程的状态
xinbumi的博客
05-07 410
在一个已经结束的线程上再次启动线程会报异常
Java线程的6种状态及切换(透彻讲解)
热门推荐
潘建南的博客
12-24 26万+
Java中线程的状态分为6种。 1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。 2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。 线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状...
Java中线程的6种状态
最新发布
SHI940637335的博客
08-11 550
那如果在RUNNABLE的线程再次调用start呢？其实就会 线程状态的异常。就是底层源码在调用start()方法的时候 针对状态做了判断， 如果不是NEW状态就会报线程状态的异常。如果线程执行完，再调用一次start又会怎么样？所以肯定也是报错啊！我们知道 ， 虽然很多八股文面试题中说Java创建线程的方式有3种、4种，或者更多种，但实际上他们底层都是new Thread()那当创建完一个Thread，这时线程处于NEW状态，那这时调用start()方法，会让线程进入到RUNNABLE状态。
Java多线程:线程状态
清风小阁
03-04 4万+
一. 线程状态类型 1. 新建状态（New）：新创建了一个线程对象。 2. 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。 3. 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。 4. 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂
Java线程状态
seaboat——a free boat on the sea.（公众号：远洋号）
11-29 3247
线程跟人类一样拥有自己的生命周期，一条线程从创建到执行完毕的过程即是线程的生命周期，此过程可能在不同时刻处于不同的状态，线程状态正是这小节的主题，线程到底有多少种状态？不同状态之间是如何转化的？ 对于线程的状态的分类并没有严格的规定，只要能正确表示状态即可，如图2-5-7-1，先看其中一种状态分类，一个线程从创建到死亡可能会经历若干个状态，但在任意一个时间点线程只能处于其中一种状态，总共包含五个
Java并发编程总结——慎用CAS详解
09-02
Java并发编程中，CAS（Compare and Swap，比较并交换）是一种无锁算法，常用于实现原子操作，它在多线程环境下提供了数据的一致性。然而，CAS并不是万能的，过度依赖或不当使用可能会导致问题。下面我们将深入探讨...
Java并发编程之——Amino框架
08-10
Java并发编程是一个复杂而重要的主题，它涉及到多线程、同步机制、线程池和并发容器等关键概念。Amino框架是Java并发编程领域的一个工具，它旨在简化并发编程，提高程序的性能和可维护性。这篇博客文章可能详细探讨...
java并发编程——内存模型
02-24
且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行——源自百度百科在并发编程中，我们需要处理两个关键问题：线程之间如何通信和线程之间如何同步，后续篇章将围绕这两个问题进行...
Java多线程
ldsfsm的博客
05-08 174
了解进程和线程: 几乎所有的操作系统都支持进程的概念，所有运行中的任务通常对应一个进程（Process）。当一个程序 进入内存运行时，即变成一个进程。进程是处于运行过程中的程序，并且具有一定的独立功能，进程是 系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。 独立性：进程是系统中独立存在的实体，它可以拥有自己独立的资源，每一个进程都拥有自己私有 的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空 间。 动态性：进程与程序的区别在于，程序只是一个静态的指
java线程状态
inspiredbh的博客
02-09 383
线程一般具有五中状态：新建，就绪，运行，阻塞，死亡 新建状态(new)： 在程序中创建了一个线程对象之后，线程便处于新建状态，已经分配了相应内存空间和其他资源，但是处于不可运行的状态 就绪状态(Runnable)： 线程对象调用了start()方法后，便启动了线程，线程启动后由创建状态转为就绪状态，j就绪状态相当于等待执行，进入线程队列排队，等待cpu执行，已经具备了执行资格 运行sta
Java 线程的状态
柚咖小窝
03-24 423
线程状态   Java 中我们说的线程状态在代码中的实现其实就是一个变量的值，这个变量是 Thread 类中的变量——threadStatus。 /* Java thread status for tools, * initialized to indicate thread 'not yet started' */ private volatile int threadStatus = 0;   因为 threadStatus 是个整型数据，不形象，因此 Thread 将 threadStatus.
Java中线程的状态
m0_72466001的博客
10-08 373
Java中线程的状态
Java知识点——线程的状态
htfenght的博客
12-05 428
线程的状态 初始态： NEW创建一个Thread对象，但还未调用start()启动线程时，线程处于初始态。 运行态： RUNNABLE在Java中，运行态包括就绪态 和 运行态。 就绪态 该状态下的线程已经获得执行所需的所有资源，只要CPU分配执行权就能运行。 所有就绪态的线程存放在就绪队列中。 运行态 获得CPU执行权，正在执行的线程。 由于一个CPU同一时刻只能执行一条线程，因...
java线程的状态
m0_46546381的博客
05-20 173
线程的六种状态： Java语言定义了6种线程状态， 在任意一个时间点中， 一个线程只能有且只有其中的一种状态， 并且可以通过特定的方法在不同状态之间转换。 这6种状态分别是： ·新建（New） ： 创建后尚未启动的线程处于这种状态。 ·运行（Runnable）： 包括操作系统线程状态中的Running和Ready， 也就是处于此状态的线程有可能正在执行， 也有可能正在等待着操作系统为它分配执行时间。 ·无限期等待（Waiting） ： 处于这种状态的线程不会被分配处理器执行时间， 它们要等待被其他线程显式唤
Java线程的状态
成长日记的博客
05-28 83
新建（New） //线程只有获得CPU之后才能执行 可运行（Runnable） 正在运行（Running） 阻塞（Block） 终止（Dead） 这学期学了操作系统- -感觉比较好理解啦 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值