java 进程 jvm_十七、线程和进程、java程序的运行原理、jvm

1、线程的含义：

线程是一个进程中的执行场景，一个进程可以启动多个线程。多线程不是为了执行速度，而是为了提高应用程序的使用率，线程和线程共享“堆内存和方法区内存”，栈内存是独立的，一个线程一个栈。

线程的另一种理解：是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

2、进程的含义：

一个进程对应一个应用程序，启动一个应用程序也就启动了一个进程，现在的计算机都是支持多进程操作的，在同一个操作系统中可以同时启动多个进程。多进程的作用不是提高执行速度，而是提高CPU的使用率。进程和进程之间的内存是独立的。

3、java程序的运行原理：

java命令启动java虚拟机，启动jvm等于启动了一个应用程序，表示启动了一个进程。该进程会自动的启动一个“主线程”，然后主线程去调用某个类的main方法，所以main方法运行在主线程中。在此之前的程序都是单线程的，并且我们所有的方法都是在主线程中运行的

运行原理详解

4、线程的创建和启动：

|方式一：|

A、继承java.lang.Thread类

B、重写run方法

public class Processor extends Thread {

@Override

public void run() {

for(int i=0;i<9;i++){

System.out.println("Thread---->"+i);

}

}

}

public class ThreadTest01 {

public static void main(String[] args) {

//创建线程

Thread t=new Processor();

//启动线程：这段代码执行瞬间结束，就是告诉jvm再分配一个新的栈给t线程，t线程会自动调用run()方法

t.start();

/*有了多线程之后，main方法结束，只是主线程栈中没有方法栈帧了，

但是其他线程或者其他栈中还有栈帧。所以main方法结束程序可能还在运行。

*/

}

}

|方式二：|

A：实现Runnable接口，

B：实现run()方法

public class Processor02 implements Runnable {

//这种方式是推荐的，因为一个类实现接口之外保留了类的继承

@Override

public void run() {

for(int i=0;i<10;i++){

System.out.println("run-->"+i);

}

}

}

public class ThreadTest02 {

public static void main(String[] args) {

Thread t=new Thread(new Processor02());

t.start();

}

}

5、线程的生命周期

1)五个状态：新建、就绪、运行、阻塞、消亡；

2)CPU时间片：

通常计算机只有一个CPU，CPU在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令，在单CPU的机器上线程不是并行运行的，只有多个CPU上线程上才可以并行运行。

java虚拟机要负责线程的调度，取得CPU的使用权，目前有两种调度模型：分时调度模型和抢占式调度模型。

分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片。

抢占式调度模型：优先让优先级别高的线程使用CPU，如果线程的CPU的优先级相同，那么会随机选择一个，优先级别高的线程获取的CPU时间片相对多一些。

线程的优先级主要分为三种：MAX_PRIORITY(最高级);MIN_PRIORITY(最低级);   NORM_PRIORITY(标准)默认

线程的最高优先级是10，最低优先级是1，默认优先级是5，所以优先级从1到10；

|示例：给线程设置优先级|

public class Processor04 extends Thread {

@Override

public void run() {

for(int i=0;i<10;i++){

System.out.println(Thread.currentThread().getName()+"--->"+i);

}

}

}

public class ThreadTest4 {

public static void main(String[] args) {

System.out.println(Thread.MAX_PRIORITY);

System.out.println(Thread.MIN_PRIORITY);

System.out.println(Thread.NORM_PRIORITY);

Thread thread2=new Processor04();

thread2.setName("t2");

thread2.setPriority(3);

Thread thread1=new Processor04();

System.out.println(thread1.getName());//Thread-0

thread1.setName("t1");

System.out.println(thread1.getName());//t1

System.out.println(thread1.getPriority());//默认的优先级为 5

thread1.setPriority(9);//t1线程先执行

thread1.start();

thread2.start();

}

}

|示例：阻塞线程|

public class Processor05 extends Thread {

public void run(){

for(int i=0;i<10;i++){

System.out.println(Thread.currentThread().getName()+"-->"+i);

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

try {

m1();

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

public static void m1() throws Exception{

}

}

|示例：终止线程的|

public class Processor06 implements Runnable {

boolean run=true;

@Override

public void run() {

for(int i=0;i<10;i++){

if(run){

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}else{

return;

}

System.out.println(Thread.currentThread().getName()+"-->"+i);

}

}

}

public class ThreadTest06 {

public static void main(String[] args) {

Processor06 pro=new Processor06();

Thread thread=new Thread(pro);

thread.setName("t");

thread.start();

//用户指定多长时间后后线程终止：

try {

Thread.sleep(5000);//用户指定5秒后

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

//在5秒钟之后通过run=false使得run方法不再执行，从而终止线程

pro.run=false;//线程终止

}

}

|示例：Thread类中的yield方法|

Thread类中有一个yield方法它与sleep()类相似，只是不能由用户指定暂停多长时间，并且yield()方法只能让同优先级的线程有执行的机会

public class Processor07 extends Thread {

/*

Thread.yield();

1.该方法是一个静态方法

2.作用：给同一个优先级别的线程让位，但是让位时间不固定

3.和sleep方法相同，就是yield时间不固定

*/

@Override

public void run() {

for(int i=0;i<1000;i++){

System.out.println(Thread.currentThread().getName()+"-->"+i);

if(i%20==0){

Thread.yield();

}

}

}

}

public class ThreadTest07 {

public static void main(String[] args) {

Thread thread=new Processor07();

thread.setName("t1");

thread.start();

for(int i=0;i<500;i++){

System.out.println(Thread.currentThread().getName()+"-->"+i);

}

}

}

|Thread中的join()方法使用：|

t线程去调用了join方法，调用后main线程将被阻塞不执行，直到t线程执行完毕，main线程才会执行；

public class Processor08 implements Runnable {

@Override

public void run() {

for(int i=0;i<10;i++){

try{

Thread.sleep(100);

System.out.println(Thread.currentThread().getName()+"-->"+i);

}catch(InterruptedException e){

}

}

}

}

public class ThreadTest08 {

public static void main(String[] args) {

Thread thread=new Thread(new Processor08());

thread.setName("t");

thread.setPriority(10);

thread.start();

try {

thread.join();//表示将t线程合并到主线程中，也就意味着两个栈空间变成了一个栈空间，

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

//主线程

for(int i=0;i<50;i++){

System.out.println(Thread.currentThread().getName()+"-->"+i);

}

}

}

5、jvm

1) 什么是JVM?

2) JRE/JDK/JVM是什么关系?

3) JVM原理

4)JVM执行程序的过程

5)JVM的生命周期

6)JVM的体系结构

7)JVM运行时数据区