进程是程序的一次执行过程，在java中启动main函数就是启动了一个JVM进程
例如，当执行下面两个类时，即启动了两个进程：
public class ProcessTest {
public static void main(String[] args) {
while(true){
try {
Thread.sleep(2000);
System.out.println("Process1 running ...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class ProcessTest2 {
public static void main(String[] args) {
while(true){
try {
Thread.sleep(2000);
System.out.println("Process2 running ...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
线程可以理解成是进程的更小执行单元，一个进程在执行过程中可以产生多个线程，与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程，在上例中一个进程只产生了一个线程即主线程，在以下例子中，共有三个线程在运行即 main ，Thread-0，Thread-1 。
public class ThreadTest extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(2000);
System.out.println(Thread.currentThread().getName() + " running...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
new ThreadTest().start();
new ThreadTest().start();
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(2000);
System.out.println(Thread.currentThread().getName() + " running...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
main running... Thread-1 running... Thread-0 running... Thread-1 running... main running... Thread-0 running... Thread-1 running... main running... ........................实现多线程的三种方式：
- 继承 Thread 类
- 实现 Runnable 接口
- 通过线程池 Executors.newCachedThreadPool 启动
一定是当前线程调用此方法，当前线程进入TIMED_WAITING状态，但不释放对象锁，millis后线程自动苏醒进入就绪状态。作用：给其它线程执行机会的最佳方式。
package com.hs.example.base.multithread.day01;
public class SleepTest implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getState());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Thread thread = new Thread(new SleepTest());
thread.start();
do {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(thread.getState());
} while (!Thread.State.TERMINATED.equals(thread.getState()));
}
}
程序运行结果为：
RUNNABLE TIMED_WAITING RUNNABLE RUNNABLE TIMED_WAITING ........省略 TERMINATEDThread.yield()：
yield 字面意思为让步，jdk文档解释为 暂停当前正在执行的线程对象，并执行其他线程，调用该方法会释放CPU资源，但不会释放锁资源，当前线程从运行中状态进入就绪状态，Thread.yield()不会导致阻塞。该方法与sleep()类似，只是不能由用户指定暂停多长时间
join ：等待该线程终止，一般使用方法为在当前线程A调用线程B的join方法，此时A线程会等待B线程执行完才会继续执行。
public class JoinTest implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName() + " start...");
Thread thread = new Thread(new JoinTest());
thread.start();
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " end...");
}
}
此例中执行结果为：
main start... Thread-0 0 Thread-0 1 Thread-0 2 Thread-0 3 Thread-0 4 Thread-0 5 Thread-0 6 Thread-0 7 Thread-0 8 Thread-0 9 main end...
但是如何注释 thread.join(); 执行结果为：
main start... main end... Thread-0 0 Thread-0 1 Thread-0 2 Thread-0 3 Thread-0 4 Thread-0 5 Thread-0 6 Thread-0 7 Thread-0 8 Thread-0 9线程状态：
下例中，一个线程运行时，另外一个线程属于阻塞状态
public class BlockedThreadTest implements Runnable {
private final Object o = new Object();
@Override
public void run() {
synchronized (o) {
System.out.println(Thread.currentThread().getName() + " " + Thread.currentThread().getState());
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + Thread.currentThread().getState());
System.out.println(Thread.currentThread().getName() + " end");
}
}
public static void main(String[] args) {
Runnable runnable = new BlockedThreadTest();
Thread t1 = new Thread(runnable);
t1.setName("t1");
t1.start();
Thread t2 = new Thread(runnable);
t2.setName("t2");
t2.start();
do {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(t1.getName() + ":" + t1.getState() + " " + t2.getName() + ":" + t2.getState());
} while (!Thread.State.TERMINATED.equals(t1.getState()) || !Thread.State.TERMINATED.equals(t2.getState()));
}
}
t1 RUNNABLE t1:TIMED_WAITING t2:BLOCKED t1:TIMED_WAITING t2:BLOCKED t1:TIMED_WAITING t2:BLOCKED t1:TIMED_WAITING t2:BLOCKED t1:TIMED_WAITING t2:BLOCKED t1:TIMED_WAITING t2:BLOCKED t1:TIMED_WAITING t2:BLOCKED t1:TIMED_WAITING t2:BLOCKED t1:TIMED_WAITING t2:BLOCKED t1 RUNNABLE t1 end t2 RUNNABLE t1:TERMINATED t2:TIMED_WAITING t1:TERMINATED t2:TIMED_WAITING t1:TERMINATED t2:TIMED_WAITING t1:TERMINATED t2:TIMED_WAITING t1:TERMINATED t2:TIMED_WAITING t1:TERMINATED t2:TIMED_WAITING t1:TERMINATED t2:TIMED_WAITING t1:TERMINATED t2:TIMED_WAITING t1:TERMINATED t2:TIMED_WAITING t1:TERMINATED t2:TIMED_WAITING t2 RUNNABLE t2 end t1:TERMINATED t2:TERMINATED
参考：
https://www.zhihu.com/question/264627396
https://blog.csdn.net/shinecjj/article/details/82995309
