线程和进程

---

进程和线程

进程

在计算机中，进程代表了内存中正在运行的应用程序，计算机中的资源（cpu 内存 磁盘 网络等），会按照需求分配给每个进程，从而这个进程对应的应用程序就可以使用这些资源了。

在操作系统中，启动一个应用程序的时候，会有一个或多个进程同时被创建，这些进程其实就表示了当前这个应用程序，在系统中的资源使用情况以及程序运行的情况。如果关闭这个进程，那么对应的应用程序也就关闭了。
所以，进程就是在系统中，运行一个应用程序的基本单位。

线程

线程是进程中的一个代码执行单元，负责当前进程中代码程序的执行，一个进程中有一个或多个线程。
当一个进程中启动了多个线程去分别执行代码的时候，这个程序就是多线程程序。

案例

例如，当前我们去运行一个类的时候，会先启动JVM，这个JVM对于计算机来讲，就是一个
应用程序，所以同时系统中也会启动一个进程和这个JVM对应：

public  class hello{public static void main(String[] args)throws Exception{System.out.println("hello");long time = 1000*100L;Thread.sleep(time);System.out.println("world");}
}

我们运行这个代码：

注意，代码中，输出hello之后，JVM并没有直接结束，而是让当前线程去休眠了100秒，所以这个时候JVM还在运行着，我们可以在任务管理器中，看到JVM对应的进程了

除此之外，我们还可以使用JDK中提供的工具，来查看JVM当前的运行情况，在cmd中输入jconsole,然后连接：

这里通过JDK自带的jconsole工具，可以检测到当前运行Hello这个类的时候，JVM的运行情况，包含内存的使用、线程的运行状态、类的加载等信息.

例如，查看当前JVM中执行main方法线程信:

(注意，这线程的名字就叫main，它是任务就是调用执行我们类中的main方法,所以，是一个名字叫main的线程，调用执行我们代码中的main方法)

时间片概念

时间片，当前一个线程要使用CPU的时候，CPU会分配给这个线程一小段时间（毫秒级别），这段时间就叫做时间片，也就是该线程允许使用CPU运行的时间，在这个期间，线程拥有CPU的使用权。

如果在一个时间片结束时，线程还在运行，那么这时候，该线程就需要停止运行，并交出CPU的使用
权，然后等待下一个CPU时间片的分配。

（在宏观上，一段时间内，我们感觉两个线程在同时运行代码，其实在微观中，这俩个线程在使用
一个CPU的时候，它们是交替着运行的，每个线程每次都是运行一个很小的时间片，然后就交出CPU使用权，只是它们俩个交替运行的速度太快了，给我们的感觉，好像是它们俩个线程在同时运行。）

调度方式

当俩个或多个线程使用一个CPU来运行代码的时候，在操作系统的内核中，就会有相应的算法来控制线程获取CPU时间片的方式，从而使得这些线程可以按照某种顺序来使用CPU运行代码，这种情况被称为线程调用。

常见的调度方式有两种：

• 时间片轮转
  所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
• 抢占式调度
  系统会让优先级高的线程优先使用 CPU（提高抢占到的概率），但是如果线程的优先级相同，那么会随机选择一个线程获取当前CPU的时间片。

（JVM中的线程，使用的为抢占式调度。）

线程的创建和启动

java.lang.Thread 是java中的线程类，所有的线程对象都必须是Thread类或其子类的实例。

每个线程的作用，就是完成我们给它指定的任务，实际上就是执行一段我们指定的代码。我们只需要在Thread 类的子类中重写 run 方法，把执行的代码写入到run方法中即可，这就是线程的执行任务

Java中通过继承Thread类来创建并启动一个新的线程的步骤如下：

1. 定义 Thread 类的子类（可以是匿名内部类），并重写 Thread 类中的 run 方法， run 方法中的
   代码就是线程的执行任务
2. 创建 Thread 子类的对象，这个对象就代表了一个要独立运行的新线程
3. 调用线程对象的 start 方法来启动该线程

第一种创建方式

package shixun;public class myTest {public static void main(String[] args) {MyThread myThread=new MyThread();myThread.start();}
}class MyThread extends Thread{@Overridepublic void run() {int x=0;while(true){String name = Thread.currentThread().getName();System.out.println("hello, ["+name+"] - "+(x++));try{Thread.sleep(1000);}catch(Exception e){e.printStackTrace();}}}
}

第二种创建方式（匿名内部类）

package shixun;public class myTest {public static void main(String[] args) {Thread thread=new Thread(){@Overridepublic void run() {int x=0;while(true){String name = Thread.currentThread().getName();System.out.println("hello, ["+name+"] - "+(x++));try{Thread.sleep(1000);}catch(Exception e){e.printStackTrace();}}}};thread.start();}
}

第三种创建方式（Runnable接口）

package shixun;public class myTest {public static void main(String[] args) {Thread thread=new Thread(new Runnable() {@Overridepublic void run() {int x=0;while(true){String name = Thread.currentThread().getName();System.out.println("hello, ["+name+"] - "+(x++));try{Thread.sleep(1000);}catch(Exception e){e.printStackTrace();}}}},"线程的名字");  //第二个参数可以指定idthread.start();}
}

main线程和t线程之间的关系

在此过程中，main线程和t线程之间的关系是： main线程在执行main方法的过程中，创建并启动了t线程，并且t线程启动后，和main线程就没有关系了，这时候main线程和t线程都是自己独立的运行，并且他们俩个是要争夺CPU的时间片（使用权）的。

线程的名字

通过Thread类中的currentThread方法，可以获取当前线程的对象，然后调用线程对象的getName方法，可以获取当前线程的名字。 String name = Thread.currentThread().getName();

（注意，这里说的当前线程，指的是执行当前方法的线程，因为获取线程名字的代码肯定是写在某个方法中的，并且这个方法一定是由某个线程调用执行的。）

例如：

package shixun;public class myTest {public static void main(String[] args) {String name = Thread.currentThread().getName();System.out.println("执行当前main方法的线程是："+name);Thread thread=new Thread(new Runnable() {@Overridepublic void run() {String name1 = Thread.currentThread().getName();System.out.println("执行当前run方法的线程是："+name1);}});thread.start();}
}

(注意，一定要记得，start方法启动线程后，线程会自动执行run方法,千万不要直接调用run方法，这样就不是启动线程执行任务，而是普通的方法调用。)

默认情况下，主线程中，创建出的线程，它们的都会有一个默认的名字,如Thread-0 Thread-1
Thread-2等等，我们也可以创建线程对象的时候，给它设置一个指定的名字：

Thread t = new Thread("t线程");
//或者
Thread t = new Thread(new Runnable(){public void run(){//执行任务}
},"t线程");
//或者
Thread t = new Thread();
t.setName("t线程");

线程的优先级

线程的优先级使用int类型数字表示，最大是10，最小是1，默认的优先级是5。
当俩个线程争夺CPU时间片的时候：
优先级相同，获得CPU使用权的概率相同
优先级不同，那么高优先级的线程有更高的概率获取到CPU的使用权（只是有更高的概率，并不是一定能获取到）

例如：不设置优先级的情况下，t1和t2线程各自运行10000次循环，看哪个线程先运行完

package shixun;public class myTest {public static void main(String[] args) {Thread thread1=new Thread("t1线程"){@Overridepublic void run() {String name = Thread.currentThread().getName();for (int i = 0; i < 10000; i++) {}System.out.println(name+"线程执行完毕");}};Thread thread2=new Thread("t2线程"){@Overridepublic void run() {String name = Thread.currentThread().getName();for (int i = 0; i < 10000; i++) {}System.out.println(name+"线程执行完毕");}};System.out.println("t1线程的优先级："+thread1.getPriority());System.out.println("t2线程的优先级："+thread2.getPriority());thread1.start();thread2.start();}
}

（注意，默认情况下，俩个线程的优先级都是5，那个俩个线程争夺到CPU的使用权的概率一样，那么基本上俩个线程都有相同的概率先执行完10000次循环，其实t1先稍微占了那么一点点的优势，因为毕竟在主线程的代码中，先启动了t1先，然后又启动了t2线程）

然后设置优先级再来运行一下：

设置完t1和t2优先级之后，在运行结果中会明显看到优先级高的t2线程，会有更高的概率先执行完
代码。

线程状态

线程的状态分为以下几种：

线程状态	描述
NEW（新建）	线程刚被创建，还没调用start方法，或者刚刚调用了start方法，调用 start方法不一定"立即"改变线程状态，中间可能需要一些步骤才完成一个线程的启动。
RUNNABLE(可运行)	start方法调用结束,线程由NEW变成RUNNABLE，线程存活着，并尝试抢占CPU资源，或者已经抢占到CPU资源正在运行，这俩种情况的状态都显示为RUNNABLE
BLOCKED（锁阻塞）	线程A和线程B都要执行方法test，而且方法test被加了锁，线程A先拿到了锁去执行test方法，线程B这时候需要等待线程A把锁释放。这时候线程B就是处理BLOCKED
WAITING（无限期等待）	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入 Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
TIMED_WAITING（有限期等待）	和WAITING状态类似，但是有一个时间期限，时间到了，自己也会主动醒来
TERMINATED（终止）	run方法执行结束的线程处于这种状态。

其实 BLOCKED，WAITING，TIMED_WAITING 这三种都属于线程阻塞，只是触发的条件不同，以及从阻塞状态中恢复过来的条件也不同而已。

线程在这三种情况的阻塞下，都具备相同的特点：
1.线程不执行代码
2.线程也不参与CPU时间片的争夺

例如：一个线程，经历的最普通的过程如下：

package shixun;public class myTest {public static void main(String[] args) {Thread thread1=new Thread("t1线程"){@Overridepublic void run() {String name = Thread.currentThread().getName();for (int i = 0; i < 100000; i++) {}}};System.out.println(thread1.getState());thread1.start();System.out.println(thread1.getState());System.out.println(thread1.getState());System.out.println(thread1.getState());System.out.println(thread1.getState());System.out.println(thread1.getState());System.out.println(thread1.getState());}
}

刚创建好的线程对象，就是出于NEW的状态。
线程启动后，会出于RUNNABLE状态，这个RUNNABLE状态包含俩种情况：
1.就绪状态，此时这个线程没有运行，因为没有抢到CPU的执行权
2.运行状态，此时这个线程正在运行中，因为抢到CPU的执行权