什么是进程,什么是线程

  1. 进程是一个应用程序(一个软件)<br />    线程是进程中的执行场景/执行单元<br />    一个进程可以启动多个线程    <br />    最起码,现在的java程序至少有两个线程并发,一个执行main方法的主线程,一个垃圾回收线程.

线程和进程的关系

进程之间的内存不会共享<br />    java虚拟机中:堆内存和方法区是共享的,但是栈不共享,一个线程一个栈<br />    假设有10个线程,那么就会有10个栈空间,各自相互独立运行,互不干扰,这就是多线程并发.<br />    java之所以有多线程机制,目的是为了提高程序处理的效率<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/12988934/1620534890037-3963984f-1141-4e25-88b1-5f54e9e662d2.png#height=634&id=XeURW&margin=%5Bobject%20Object%5D&name=image.png&originHeight=634&originWidth=1267&originalType=binary&size=235214&status=done&style=none&width=1267)
  • 对于单核的CPU来说,真的可以做到多线程并发吗

不能真正做到多线程并发,但是可以给人一种多线程并发的感觉.

//分析程序之外有几个线程

public class Main{
    public static void main(String []args){

    }
}

实现线程的两种方式

第一种

  • 编写一个类,继承java.lang.Thread,重写run方法(java支持多线程机制,已经将多线程实现了,我们只需要继承就可以了)
    1. 首先编写一个类,重写run方法
    2. 在主线程创建一个分支线程对象,—启动线程 ```java class MyThread extends Thread{ @Override public void run() { //编写程序运行在分支线程中(分支栈) for (int i = 0; i < 1000; i++) {
        System.out.println("分支线程-->"+i);
      } } }

public class Thread01 { public static void main(String[] args) { //这里是main方法,这里的代码属于主线程,在主栈中运行 //新建一个分支线程对象 MyThread myThread = new MyThread(); //启动线程 myThread.start();//在jvm中开启一个新的栈空间,立刻结束

    for (int i = 0; i < 1000; i++) {
        System.out.println("主线程-->"+i);
    }

}

} //输出结果 主线程—>0 分支线程—>0 主线程—>1 分支线程—>1 主线程—>2 主线程—>3 主线程—>4

> MyThread.run 和MyThread.start的区别

![image.png](https://cdn.nlark.com/yuque/0/2021/png/12988934/1620565060980-c66cc358-6342-48c5-9a41-e829ce566d4b.png#height=599&id=mVtO4&margin=%5Bobject%20Object%5D&name=image.png&originHeight=599&originWidth=1252&originalType=binary&size=203936&status=done&style=none&width=1252)

 ![image.png](https://cdn.nlark.com/yuque/0/2021/png/12988934/1620565548022-6aad1888-2313-456e-b35a-d0e72b0787a0.png#height=583&id=xOFb9&margin=%5Bobject%20Object%5D&name=image.png&originHeight=583&originWidth=1243&originalType=binary&size=344416&status=done&style=none&width=1243)
<a name="9tmmZ"></a>
#### 第二种方式
```java
package ThreadTest;

public class ThreadT02 {
    public static void main(String[] args) {
        //创建一个可以运行的对象
        MyRunnable r = new MyRunnable();
        //将这个可以运行的对象封装成一个线程对象
        Thread t = new Thread(r);
        //启动线程
        t.start();
    }
}
//这并不是一个线程类,是一个可以运行的类
class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("分支线程执行");
    }
}

//采用接口的方式实现多线程
class Thread03{
    public static void main(String[] args) {
        new Thread(() -> System.out.println("分支线程匿名内部类和lambda表达式")).start();
    }
}

线程的生命周期

image.png