---

什么是程序?

是为完成特定任务，用某种语言编写的一组指令集合。`
简单的说：就是我们写的代码

---

什么是进程?

进程是指运行中的程序，操作系统会为进程分配内存空间
进程是你程序的一次执行过程，或是正在运行的一个程序，是动态 过程，它自身的产生、存在和消亡过程

启动一个程序

启动两个程序

结束进程之后，进程就随之消亡

---

什么是线程？

1.线程是由进程创建的，是进程的实体
2.一个进程可以拥有多个线程
当你在使用百度网盘下载东西的时候，你可以将百度网盘的整体界面看成一个进程，当它每次下载一个东西的时候对应启动一个线程

单线程与多线程

单线程：同一时刻，只允许执行一个线程
多线程：同一时刻，可以执行多个线程，比如百度网盘下载东西

并发与并行

并发：同一时刻，多个任务交替执行，造成一种你好像看起来它们同时的错觉，简单的说，单核cpu实现的多任务就是并发
并行：同一时刻，多个任务同时执行,多核cpu可以实现并行
你可以将cpu想象成我们的大脑，一个人只有一个，你能遍看电视遍写作业吗，在你心里可能感觉你可以有这个能力，但其实你这是在看电视和做作业的过程中来回不断切换

并发和并行可能同时存在

---

线程的使用

用java查看有多少个cpu

示例代码：

public class CpuNum {
    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
        //获取当前电脑的cpu数量
        int cpuNums = runtime.availableProcessors();
        System.out.println("当前有cpu个数 = "+cpuNums);
    }
}

运行结果:

创建线程的两种方式

继承Thread类，重写run方法

示例：每隔1s输出一句小猫喵喵叫

public class Thread01 {
    public static void main(String[] args) {
        //创建Cat对象，可以当线程使用
        Cat cat = new Cat();
        cat.start();//启动线程
    }
}
//1.当一个类继承了Thread类，该类就可以当作线程使用
//2.我们会重写run方法，写上自己的业务代码
//3.run Thread 类 实现了Runnable接口的run方法
/* @Override
public void run() {
if (target != null) {
target.run();
}
}*/
class Cat extends Thread{
    int times  = 0;
    @Override
    public void run() {//重写run方法，写上自己的业务逻辑
        while(true) {
            //该线程每隔1秒，在控制台输出”喵喵，我是小猫咪“
            System.out.println("喵喵，我是小猫咪"+(++times));
            //让该线程休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

示例：在上述的基础之后，加上一个仅仅输出8次的条件

public class Thread01 {
    public static void main(String[] args) {
        //创建Cat对象，可以当线程使用
        Cat cat = new Cat();
        cat.start();//启动线程
    }
}
//1.当一个类继承了Thread类，该类就可以当作线程使用
//2.我们会重写run方法，写上自己的业务代码
//3.run Thread 类 实现了Runnable接口的run方法
/* @Override
public void run() {
if (target != null) {
target.run();
}
}*/
class Cat extends Thread{
    int times  = 0;
    @Override
    public void run() {//重写run方法，写上自己的业务逻辑
        while(true) {
            //该线程每隔1秒，在控制台输出”喵喵，我是小猫咪“
            System.out.println("喵喵，我是小猫咪"+(++times));
            //让该线程休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times==8){
                break;//当times 到80，退出while，这时线程就会结束
            }
        }
    }
}

实现Runnable接口，重写run方法

实现案例：请编写程序，该程序可以每隔1秒，在控制台输出"hi"，当输出10次后，自动退出

public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog.start();这里不能调用start
        //创建Thread对象,把dog对象(实现Runnable)，放入Thread
        Thread thread = new Thread(dog);
        thread.start();
    }
}
class Dog implements Runnable{//通过实现Runnable接口，并发线程
    int count = 0;
    @Override
    public void run() {//普通方法
        while(true){
            System.out.println("小狗汪汪叫..hi"+(++count)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==10){
                break;
            }
        }
    }
}

这里底层使用了设计模式（代理模式）
模拟代理类

//线程代理
class ThreadProxy implements Runnable{//把Proxy当成ThreadProxy

    private Runnable target = null;//属性，类型是Runnable
    @Override
    public void run() {
        if(target!=null){
            target.run();
        }
    }

    public ThreadProxy(Runnable target){
        this.target = target;
    }
    public void start(){
        start0();//这个方法时真正实现多线程方法
    }
    public void start0(){
        run();
    }
}

---

多线程机制

多个线程同时进行

示例代码：

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建Cat对象，可以当线程使用
        Cat cat = new Cat();
        cat.start();//启动线程
        //说明：当main线程启动了一个子线程 Thread-0，主线程不会阻塞,会继续执行
        //这时，主线程和子线程是交替执行
        System.out.println("主线程继续执行"+Thread.currentThread().getName());//名字main
        for (int i=0;i<10;i++){
            System.out.println("主线程 i="+i);
            //让主线程休眠
            Thread.sleep(1000);
        }
    }
}
//1.当一个类继承了Thread类，该类就可以当作线程使用
//2.我们会重写run方法，写上自己的业务代码
//3.run Thread 类 实现了Runnable接口的run方法
/* @Override
public void run() {
if (target != null) {
target.run();
}
}*/
class Cat extends Thread{
    int times  = 0;
    @Override
    public void run() {//重写run方法，写上自己的业务逻辑
        while(true) {
            //该线程每隔1秒，在控制台输出”喵喵，我是小猫咪“
            System.out.println("喵喵，我是小猫咪"+(++times)+"线程名 = "+Thread.currentThread().getName());
            //让该线程休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times==80){
                break;//当times 到80，退出while，这时线程就会结束
            }
        }
    }
}

执行流程，当我们去运行的时候，打开一个进程，由这个进程给我们启动了一个主线程，主线程里面有开启了一个子线程，等所有线程均挂掉的时候，进程才随之结束，只要有一个线程存活，应用程序就还没有结束

为社么是start?

run方法就是一个普通的方法，没有真正的启动一个线程，就会把run方法执行完毕才向下执行，即会阻塞

源码解析

（1）

public synchronized void start(){
	start0();
}

(2)
//start0()是本地方法，是jvm调用，底层是c/c++
//真正实现多线程的效果，是start0（），而不是run
private native void start0();
start()方法调用start0()方法后，该线程并不一定会立马执行，只是将线程变成了可运行状态。具体什么时候执行，取决于CPU，由CPU统一调度。