java中线程的状态以及线程栈分析

最新推荐文章于 2024-01-29 22:51:50 发布
最新推荐文章于 2024-01-29 22:51:50 发布
阅读量3.6k 收藏 3
点赞数 2
分类专栏： Java

java中线程的状态

状态 说明
NEW 初始状态。线程刚刚被创建，并且start()方法还未被调用
RUNNABLE 运行状态。表示线程正在java虚拟机中执行，但是可能正在等待操作系统的其他资源，比如CPU
BLOCKED 阻塞状态。表示线程正在等待监视器锁。表示线程正在等待获取监视器锁，以便进入同步方法或者同步代码快，也有可能是从wait（）方法被唤醒而等待再次进入同步方法或者同步代码块
WAITING 等待状态。表示当前线程需要等待其他线程执行一些特殊操作，比如当前线程调用了a.wait()方法，它正在等待其他线程调用a.notify或a.notifyAll方法;如果当前线程调用了threada.join(),那么它在等待threada执行完成
TIMED_WAITING 超时等待。与WAITING的不同在于，该状态有超时时间
TERMINATED 终止状态，表示当前线程已经执行完毕

详细介绍：参考Thread内部类:State

WAITING与TIMED_WAITING: 
调用以下三个方法会进入WAITING状态： 
* Object.wait() 不设置超时时间 
* Thread.join() 不设置超时时间 
* LockSupport.park() 不设置超时时间 
调用下面的方法会进入TIMED_WAITING状态： 
* Object.wait(time) 
* Thread.join(time) 
* Thread.sleep(time) 
* LockSupport.parkNanos(time) 
* LockSupport.parkUntil(time)

通过jstack查看线程状态

jstack 是一个可以用来打印java进程中的线程堆栈信息的工具。一般都位于jdk安装目录的bin目录下。 
一般，jstack都用来检测死锁，以及分析当前程序运行状态。

使用方式

jstack [options] pid 
pid:即进程id，可以通过jps命令查看 
options:可选选项。一般常用的是-l和-m，-l用于打印详细的堆栈信息，包括当前线程获得到的同步器(AbstractOwnableSynchronizer)。-m则会打印包含C++或C的堆栈信息。

例如： 
命令：jstack 10968 则会把进程号为10968的进程所包含的线程信息打印出来。 
其中的部分结果如下：

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007fab88009800 nid=0x2add waiting on condition [0x00007fab8ee92000]
  2.    java.lang.Thread.State: WAITING (parking)
  3.     at sun.misc.Unsafe.park(Native Method)
  4.     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:304)
  5.     at test.DeadLockTest.main(DeadLockTest.java:17)

命令：jstack -l 10968则会包含当前线程获取到的同步器。 
其中的部分结果如下：

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007fab88009800 nid=0x2add waiting on condition [0x00007fab8ee92000]
  2.    java.lang.Thread.State: WAITING (parking)
  3.     at sun.misc.Unsafe.park(Native Method)
  4.     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:304)
  5.     at test.DeadLockTest.main(DeadLockTest.java:17)
  7.    Locked ownable synchronizers:
  8.     - None

可以看到，带-l参数的，在线程信息后面有个’ Locked ownable synchronizers:’信息。

关于jstack的使用，下面两篇文章写的很不错，非常建议一看: 
1. java-thread-dumps 
2. java-thread-dumps-2

不同线程状态在jstack信息中形式

我们来看一下，当线程处于不同状态的时候，通过jstack看到的是什么样子的。

WAITING状态

通过上面的讲解我们知道，线程进入waiting状态可以通过三种方式：1.Object.wait,2.Thread.join,3.LockSupport.park ，那么我们分别来看下，当程序分别通过这三种方式进入WAITING状态的时候，对应的jstack信息是怎样的。

1.Object.wait方式 
代码：

  
  
  1. public class WaitingTest {
  3.     public static void main(String[] args) throws InterruptedException {
  4.         // Object.wait
  5.         synchronized (WaitingTest.class) {
  6.             WaitingTest.class.wait();
  7.         }
  8.     }
  10. }

jstack 结果(省略其他部分，下同):

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007f384c009800 nid=0x2d9c in Object.wait() [0x00007f385268b000]
  2.    java.lang.Thread.State: WAITING (on object monitor)
  3.     at java.lang.Object.wait(Native Method)
  4.     - waiting on <0x00000000d6ddb9a0> (a java.lang.Class for test.WaitingTest)
  5.     at java.lang.Object.wait(Object.java:502)
  6.     at test.WaitingTest.main(WaitingTest.java:8)
  7.     - locked <0x00000000d6ddb9a0> (a java.lang.Class for test.WaitingTest)

2.Thread.join方式 
代码：

  
  
  1. public static void main(String[] args) throws InterruptedException {
  2.         // Thread.join
  3.         Thread thread = new Thread() {
  5.             @Override
  6.             public void run() {
  7.                 System.out.println("run");
  8.                 try {
  9.                     Thread.sleep(1000 * 300);
  10.                 } catch (InterruptedException e) {
  11.                     e.printStackTrace();
  12.                 }
  13.             }
  15.         };
  16.         thread.start();
  18.         // 当前线程调用thread线程的join方法
  19.         thread.join();
  20.         // 只有thread的run方法执行完成之后，才会执行输出
  21.         System.out.println("Current thread running");
  22.     }

jstack:

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007f88cc009800 nid=0x2f10 in Object.wait() [0x00007f88d5b73000]
  2.    java.lang.Thread.State: WAITING (on object monitor)
  3.     at java.lang.Object.wait(Native Method)
  4.     - waiting on <0x00000000d6ddddf8> (a test.WaitingTest$1)
  5.     at java.lang.Thread.join(Thread.java:1245)
  6.     - locked <0x00000000d6ddddf8> (a test.WaitingTest$1)
  7.     at java.lang.Thread.join(Thread.java:1319)
  8.     at test.WaitingTest.main(WaitingTest.java:23)
  10.    Locked ownable synchronizers:
  11.     - None

3.LockSupport.park方式 
代码：

  
  
  1. public static void main(String[] args) throws InterruptedException {
  2.         LockSupport.park();
  3.     }

jstack:

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007f6efc009800 nid=0x2f88 waiting on condition [0x00007f6f034dd000]
  2.    java.lang.Thread.State: WAITING (parking)
  3.     at sun.misc.Unsafe.park(Native Method)
  4.     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:304)
  5.     at test.WaitingTest.main(WaitingTest.java:8)
  7.    Locked ownable synchronizers:
  8.     - None
TIMED_WAITING

1.Object.wait(time) 
代码：

  
  
  1. public static void main(String[] args) throws InterruptedException {
  2.         synchronized (WaitingTest.class) {
  3.             WaitingTest.class.wait(1000 * 50);
  4.         }
  5.     }

jstack:

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007fd598009800 nid=0x301b in Object.wait() [0x00007fd59eea0000]
  2.    java.lang.Thread.State: TIMED_WAITING (on object monitor)
  3.     at java.lang.Object.wait(Native Method)
  4.     - waiting on <0x00000000d6ddb9b8> (a java.lang.Class for test.WaitingTest)
  5.     at test.WaitingTest.main(WaitingTest.java:9)
  6.     - locked <0x00000000d6ddb9b8> (a java.lang.Class for test.WaitingTest)
  8.    Locked ownable synchronizers:
  9.     - None

2.Thread.join(time) 
代码:

  
  
  1. public static void main(String[] args) throws InterruptedException {
  2.         // Thread.join
  3.         Thread thread = new Thread() {
  5.             @Override
  6.             public void run() {
  7.                 System.out.println("run");
  8.                 try {
  9.                     Thread.sleep(1000 * 300);
  10.                 } catch (InterruptedException e) {
  11.                     e.printStackTrace();
  12.                 }
  13.             }
  15.         };
  16.         thread.start();
  18.         // 当前线程调用thread线程的join方法
  19.         thread.join(1000 * 200);
  20.         // 只有thread的run方法执行完成之后，才会执行输出
  21.         System.out.println("Current thread running");
  22.     }

jstack:

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007f024c009800 nid=0x365c in Object.wait() [0x00007f0254768000]
  2.    java.lang.Thread.State: TIMED_WAITING (on object monitor)
  3.     at java.lang.Object.wait(Native Method)
  4.     - waiting on <0x00000000d6dddf40> (a test.WaitingTest$1)
  5.     at java.lang.Thread.join(Thread.java:1253)
  6.     - locked <0x00000000d6dddf40> (a test.WaitingTest$1)
  7.     at test.WaitingTest.main(WaitingTest.java:25)
  9.    Locked ownable synchronizers:
  10.     - None

3.Thread.sleep 
代码：

  
  
  1. public static void main(String[] args) throws InterruptedException {
  2.     Thread.currentThread().sleep(1000 * 500);
  3. }

jstack:

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007f54a8009800 nid=0x36eb waiting on condition [0x00007f54ae463000]
  2.    java.lang.Thread.State: TIMED_WAITING (sleeping)
  3.     at java.lang.Thread.sleep(Native Method)
  4.     at test.WaitingTest.main(WaitingTest.java:8)
  6.    Locked ownable synchronizers:
  7.     - None

4.LockSupport.parkNanos(time) 和 LockSupport.parkUntil(time) 两个方法类似 
代码：

  
  
  1. public static void main(String[] args) throws InterruptedException {
  2.     LockSupport.parkNanos(Long.MAX_VALUE);
  3. }

jstack:

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007eff98009800 nid=0x37b6 waiting on condition [0x00007effa0141000]
  2.    java.lang.Thread.State: TIMED_WAITING (parking)
  3.     at sun.misc.Unsafe.park(Native Method)
  4.     at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:338)
  5.     at test.WaitingTest.main(WaitingTest.java:8)
  7.    Locked ownable synchronizers:
  8.     - None
BLOCKED状态

BLOCKED状态，表示线程正在等待监视器锁。我们可以通过一个死锁的例子来分析。 
例子很简单，程序中有两个Waiter线程，WaiterA和WaitB，它们都需要获取两个锁：lock_1和lock_2,但是它们获取锁的顺序不同，因此导致了死锁。 
代码：

  
  
  1. public class WaitingTest {
  3.     private static Object lock_1 = new Object();
  4.     private static Object lock_2 = new Object();
  6.     public static void main(String[] args) throws InterruptedException {
  8.         new WaiterA().start();
  9.         new WaiterB().start();
  11.     }
  13.     static class WaiterA extends Thread {
  15.         @Override
  16.         public void run() {
  17.             // 先获取lock_1,然后再获取lock_2
  18.             synchronized (lock_1) {
  19.                 System.out.println("lock1 get,wait to get lock2");
  20.                 try {
  21.                     Thread.sleep(3 * 1000);
  22.                 } catch (InterruptedException e1) {
  23.                 }
  24.                 synchronized (lock_2) {
  25.                     System.out.println("lock2 get");
  26.                     try {
  27.                         Thread.sleep(1000 * 50);
  28.                     } catch (InterruptedException e) {
  29.                         e.printStackTrace();
  30.                     }
  31.                 }
  32.             }
  33.         }
  35.     }
  37.     static class WaiterB extends Thread {
  39.         @Override
  40.         public void run() {
  41.             // 先获取lock_2,然后再获取lock_1
  42.             synchronized (lock_2) {
  43.                 System.out.println("lock2 get,wait to get lock1");
  44.                 synchronized (lock_1) {
  45.                     System.out.println("lock1 get");
  46.                     try {
  47.                         Thread.sleep(1000 * 50);
  48.                     } catch (InterruptedException e) {
  49.                         e.printStackTrace();
  50.                     }
  51.                 }
  52.             }
  53.         }
  55.     }
  57. }

jstack:

  
  
  1. "Thread-1" #10 prio=5 os_prio=0 tid=0x00007f0d800dc800 nid=0x39da waiting for monitor entry [0x00007f0d47bfa000]
  2.    java.lang.Thread.State: BLOCKED (on object monitor)
  3.     at test.WaitingTest$WaiterB.run(WaitingTest.java:47)
  4.     - waiting to lock <0x00000000d6ddc510> (a java.lang.Object)
  5.     - locked <0x00000000d6ddc520> (a java.lang.Object)
  7.    Locked ownable synchronizers:
  8.     - None
  10. "Thread-0" #9 prio=5 os_prio=0 tid=0x00007f0d800da800 nid=0x39d9 waiting for monitor entry [0x00007f0d47cfb000]
  11.    java.lang.Thread.State: BLOCKED (on object monitor)
  12.     at test.WaitingTest$WaiterA.run(WaitingTest.java:27)
  13.     - waiting to lock <0x00000000d6ddc520> (a java.lang.Object)
  14.     - locked <0x00000000d6ddc510> (a java.lang.Object)
  16.    Locked ownable synchronizers:
  17.     - None

可以看到，上面Thread-1 和Thread-0的状态都是Blocked，原因是它们都在等待监视器锁，而Thread-1 已经获取到了锁0x00000000d6ddc520，正在等待获取0x00000000d6ddc510锁，而0x00000000d6ddc510锁已经被Thread-0获取到了，Thread-0反过来又正在等待获取0x00000000d6ddc520，而这个锁又被Thread-1获取了。 
在jstack的最后，还有如下信息：

  
  
  1. Found one Java-level deadlock:
  2. =============================
  3. "Thread-1":
  4.   waiting to lock monitor 0x00007f0d50004ed8 (object 0x00000000d6ddc510, a java.lang.Object),
  5.   which is held by "Thread-0"
  6. "Thread-0":
  7.   waiting to lock monitor 0x00007f0d500062c8 (object 0x00000000d6ddc520, a java.lang.Object),
  8.   which is held by "Thread-1"
  10. Java stack information for the threads listed above:
  11. ===================================================
  12. "Thread-1":
  13.     at test.WaitingTest$WaiterB.run(WaitingTest.java:47)
  14.     - waiting to lock <0x00000000d6ddc510> (a java.lang.Object)
  15.     - locked <0x00000000d6ddc520> (a java.lang.Object)
  16. "Thread-0":
  17.     at test.WaitingTest$WaiterA.run(WaitingTest.java:27)
  18.     - waiting to lock <0x00000000d6ddc520> (a java.lang.Object)
  19.     - locked <0x00000000d6ddc510> (a java.lang.Object)
  21. Found 1 deadlock.

就是说，已经发现了一个死锁，还有就是关于死锁的详细说明。

RUNNABLE状态

我们写一个BIO的server端，server端绑定一个端口，并通过accept()方法等待客户端链接。 
代码：

  
  
  1. public static void main(String[] args) throws InterruptedException, IOException {
  2.         ServerSocket serverSocket = new ServerSocket(9999);
  4.         while (true) {
  5.             Socket socket = serverSocket.accept();
  6.             // do something else
  7.             // ....
  8.         }
  10.     }

jstack:

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007f4b58009800 nid=0x3ab8 runnable [0x00007f4b5ff64000]
  2.    java.lang.Thread.State: RUNNABLE
  3.     at java.net.PlainSocketImpl.socketAccept(Native Method)
  4.     at java.net.AbstractPlainSocketImpl.accept(AbstractPlainSocketImpl.java:409)
  5.     at java.net.ServerSocket.implAccept(ServerSocket.java:545)
  6.     at java.net.ServerSocket.accept(ServerSocket.java:513)
  7.     at test.WaitingTest.main(WaitingTest.java:16)
  9.    Locked ownable synchronizers:
  10.     - None

可以看到，此时虽然程序在等待客户端接入，但是程序状态依然是RUNNABLE的。

TERMINATED和NEW状态

这两个状态分别表示线程生命终结和生命开始，在jstack中没有对应的信息显示。

总结：
  1. WAITING和TIMED_WAITING的主要不同就在于后者在等待的时候设置了超时时间
  2. 通过Object.wait，Thread.join两种方式进入的WAITING或者TIMED_WAITING,通过jstack查看显示的都是wait on monitor,而通过其他方式（Thread.sleep,LockSupport等）进入的WAITING或者TIMED_WAITING,通过jstack查看显示的都是waiting on condition。
  3. BLOCKED状态，通过jstack查看，显示的是waiting for monitor entry，注意与WAITING和TIMED_WAITING的区别。

java线程状态之间的转换

java线程通过不同的方法调用进入不同的状态，下面图描述的很清楚： 
java线程状态转换UML

参考资料

  1. https://sites.google.com/site/threaddumps/java-thread-dumps
  2. https://sites.google.com/site/threaddumps/java-thread-dumps-2
  3. 图片来源：http://www.uml-diagrams.org/examples/java-6-thread-state-machine-diagram-example.html

顺便推荐个很好的网站： 
Java中的UML图：http://www.uml-diagrams.org/examples/java-uml-examples.html

Pre: Kafka学习笔记之初见

Next: Java中的可重入(Reentrant)锁

生活不只*眼前的苟且
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程编程总结
01-14
Java 线程系列博文总结word化，编目如下，欢迎互相学习交流： Java线程：概念与原理 Java线程：创建与启动 Java线程：线程栈模型与线程的变量 Java线程：线程状态的转换 Java线程：线程的同步与锁 Java线程：线程的交互 Java线程：线程的调度-休眠 Java线程：线程的调度-优先级 Java线程：线程的调度-让步 Java线程：线程的调度-合并 Java线程：线程的调度-守护线程 Java线程：线程的同步-同步方法 Java线程：线程的同步-同步块 Java线程：并发协作-生产者消费者模型 Java线程：并发协作-死锁 Java线程：volatile关键字 Java线程：新特征-线程池 Java线程：新特征-有返回值的线程 Java线程：新特征-锁（上） Java线程：新特征-锁（下） Java线程：新特征-信号量 Java线程：新特征-阻塞队列 Java线程：新特征-阻塞栈 Java线程：新特征-条件变量 Java线程：新特征-原子量 Java线程：新特征-障碍器
Jstack查询线程堆栈
weixin_37862824的博客
10-18 9007
Jstack是什么？ jstack是java虚拟机自带的一种堆栈跟踪工具。 jstack主要用来查看Java线程的调用堆栈的，可以用来分析线程问题（如死锁）。线程快照是当前java虚拟机内每一条线程正在执行的方法堆栈的集合，生成线程快照的主要目的是定位线程出现长时间停顿的原因，如线程间死锁、死循环、请求外部资源导致的长时间等待等。 线程出现停顿的时候通过jstack来查看各个线程的调用堆栈，就可以知道没有响应的线程到底在后台做什么事情，或者等待什么资源。 如果java程序崩溃生成core文件，jstack工
Java线程的六种状态
The_west18的博客
01-29 458
初使状态表实线程创建成功,但没有运行,在new Thread之后,没有调用start之前,线程都处于NEW状态.
【多线程基础】 Java 线程的几种状态
书生-w的博客
03-19 2万+
线程共有6种状态：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED。分别对应于：新建、运行、阻塞、等待、带超时的等待、终止。
[Java故障排除指南- JDK11-学习笔记]-5-线程堆栈与死锁问题检测
宋小生-中间件
05-10 547
5-线程堆栈与死锁问题检测 线程堆栈分析 在程序运行时我们想要查看程序的执行状态,可以通过进程的线程堆栈信息来分析进程的健康状态,如果获取到一个运行中的Java进程的线程堆栈呢,我们可以用这几个命令: 先查询Java进程id jps -l 通过Java进程id查询当前进程的堆栈信息 jstack -l 17389 如下是实际操作中的一个案例 ➜ ~ jps -l 288 org.jetbrains.jps.cmdline.Launcher 66245 1670 sun.tools.jps.Jps
线程栈
huanglei1234567890的专栏
03-17 713
一、线程栈模型 线程栈模型是理解线程调度原理以及线程执行过程的基础。线程栈是指某时刻时内存中线程调度的栈信息，当前调用的方法总是位于栈顶，线程栈的内容是随着线程的运行状态变化而变化的，研究线程栈必须选择一个运行的时刻(指代码运行到什么地方) 上图中的栈A是主线程main的运行栈信息，当执行new JavaThreadDemo().threadMethod();方法时，thr
深入JVM剖析Java的线程堆栈
09-03
主要介绍了深入JVM剖析Java的线程堆栈,Java中的堆内存和堆栈原理的应用等知识是深入学习Java的重点,需要的朋友可以参考下
线程的五种状态
qq_37119960的博客
10-26 713
1）新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread()； 2）就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行； 3）运行状态（Running）：当CP...
Java基础1：java线程状态
boos_zhao的博客
07-03 652
等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；同步阻塞：线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；.其他阻塞：通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。就绪状态转换为运行状态：当此线程得到处理器资源；
Java线程的6种状态及切换(透彻讲解)
热门推荐
潘建南的博客
12-24 25万+
Java中线程的状态分为6种。 1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。 2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。 线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状...
【Java】Java线程有哪些状态？
Pyb_hhhhhhh的博客
05-24 873
每次提交一个任务就创建一个线程，直到线程达到线程池的最大值，一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。当任务数增加时，此线程池又可以智能的添加新线程来处理任务。线程是稀缺资源，如果无限制的创建，不仅会消耗 系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（默认 60。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。的情况下，这些闲置的线程能存活的最大时间，为。
java多线程安全性基础介绍.pptx
07-25
java多线程安全性基础介绍 线程安全 正确性 什么是线程安全性 原子性 竞态条件 i++ 读i ++ 值写回i 可见性 JMM 由于cpu和内存加载速度的差距，在两者之间增加了多级缓存导致，内存并不能直接对cpu可见。 ...
java多线程编程总结
08-26
Java线程：线程栈模型与线程的变量 Java线程：线程状态的转换 Java线程：线程的同步与锁 Java线程：线程的交互 Java线程：线程的调度-休眠 Java线程：线程的调度-优先级 Java线程：线程的调度-让步 Java线程：线程的...
java线程详解
11-10
Java线程：线程状态的转换 Java线程：线程的同步与锁 一、同步问题提出 二、同步和锁定 三、静态方法同步 四、如果线程不能不能获得锁会怎么样 五、何时需要同步 六、线程安全类 七、线程死锁 八、线程同步...
超爽的抽屉效果.zip
04-19
android 源码学习. 资料部分来源于合法的互联网渠道收集和整理，供大家学习参考与交流。本人不对所涉及的版权问题或内容负法律责任。如有侵权，请通知本人删除。感谢CSDN官方提供大家交流的平台
关于学习C语言时写的代码.zip
04-19
C语言诞生于美国的贝尔实验室，由丹尼斯·里奇（Dennis MacAlistair Ritchie）以肯尼斯·蓝·汤普森（Kenneth Lane Thompson）设计的B语言为基础发展而来，在它的主体设计完成后，汤普森和里奇用它完全重写了UNIX，且随着UNIX的发展，c语言也得到了不断的完善。为了利于C语言的全面推广，许多专家学者和硬件厂商联合组成了C语言标准委员会，并在之后的1989年，诞生了第一个完备的C标准，简称“C89”，也就是“ANSI C”，截至2020年，最新的C语言标准为2018年6月发布的“C18”。 [5] C语言之所以命名为C，是因为C语言源自Ken Thompson发明的B语言，而B语言则源自BCPL语言。 1967年，剑桥大学的Martin Richards对CPL语言进行了简化，于是产生了BCPL（Basic Combined Programming Language）语言。
机械臂论文.doc
最新发布
04-19
机械臂论文.doc
S7200 and WINCC flexible.doc
04-19
S7200 and WINCC flexible.doc
27.大学生体质测试管理系统的设计与实现-Springboot+ Mysql+Java+ B/S结构(可运行源码+数据库+设计文
04-19
27.大学生体质测试管理系统的设计与实现|Springboot+ Mysql+Java+ B/S结构(可运行源码（含数据库脚本）+开发文档+lw（高分毕设项目） 详细设计文档介绍链接：http://t.csdnimg.cn/jtyYh 内容概要： 系统主要分为系统管理员、教师和用户三个部分，系统管理员主要功能包括首页、个人中心、用户管理、教师管理、体质测试管理、测试报告管理、测试成绩管理、留言板、系统管理；基本上实现了整个大学生体质测试管理系统信息管理的过程。 全套项目源码+详尽文档，一站式解决您的学习与项目需求。 适用人群： 计算机、通信、人工智能、自动化等专业的学生、老师及从业者。 使用场景及目标： 无论是毕设、期末大作业还是课程设计，一键下载，轻松部署，助您轻松完成项目。 项目代码经过调试测试，确保直接运行，节省您的时间和精力。 其他说明： 项目整体具有较高的学习借鉴价值，基础能力强的可以在此基础上修改调整，以实现不同的功能。
java多线程的面试题
03-29
线程是程序中执行的一个单独的执行路径，每个线程都有自己的栈和程序计数器，但共享程序的内存空间。 2. 为什么使用多线程？ 多线程可以提高程序的并发性，加快程序的执行速度，提高系统的资源利用率。 3. 线程的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值