2019-10-09 新的一天开始了！

1.一个进程对应一个应用程序
2.多进程有什么作用？
单进程的计算机只能做一件事
计算机的CPU是能在某个时间点上做一件事
单核、双核、四核实现真正意义的同时处理
多进程的作用不是提高执行速度，而是提高CPU的使用率！！！！！
进程和进程之间的内存是独立的。比如游戏和音乐的内存
3.什么是线程？
线程是一个进程的执行场景。一个进程可以启动多个线程
4.多线程有什么作用？
多线程的作用不是提高执行速度，而是提高应用程序的使用率。
服务器-多个客户端
提高该应用程序的使用率
看似同时运行，其实有切换的环节的。
线程和线程共享“堆内存和方法区内存”，栈内存是独立的，一个线程一个栈。
5.java程序的运行原理？
java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，表示启动了一个进程。该进程会自动启动一个“主线程”，然后主线程去调用某个类的main方法。所以方法运行在主线程中。在其之前的所有程序都是单线程的。
JVM-->进程-->主线程-->main-->单线程

public class test01 {
    public static void main(String[] args){
        m1();
    }
    public static void m1(){
        m2();
    }
    public static void m2(){
        m3();
    }
    public static void m3(){
        System.out.println("m3.....");
    }
}

也是单线程的，只开辟一块栈空间。后进先出。只有主线程。。。。
6.在java中实现多线程的方法
继承java.lang.Thread;
重写覆盖run();（不重写并不会报错，知识新启动的线程什么都不做）

如何创建线程？
如何启动线程？
Thread t = new Processor();//父类引用指向子类对象
t.start();

/**
 * 
 */
public class test01 {
    public static void main(String[] args){
        Thread t = new Processor();
//Processor t = new Processor();
        t.start();
//并不是像常规的程序一样在主线程栈中压栈
        for(int i = 0; i < 100; i++){
            System.out.println("main-->" + i);
        }
    }
}
class Processor extends Thread{
    public void run(){
        for(int i = 0; i < 100; i++){
            System.out.println("run-->" + i);
        }
    }
}

多线程原理（继承Thread类）.jpg

<--------------------------------------------->
写一个类实现java.lang.Runnable;接口
实现run方法

public class test01 {
    public static void main(String[] args) {
//创建线程
        Thread t = new Thread(new Processor());
//启动
        t.start();
        for (int i = 0; i < 100; i++)
            System.out.println("main-->" + i);
    }
}
/**
Processor()可运行的，Thread所有已实现的接口里有Runnable接口，也是可运行的
*/
class Processor implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++)
            System.out.println("run-->" + i);
    }
}

总结：
目前我知道的实现多线程有两种方式，一种是继承Thread类，重写run方法。
首先定义线程Processor继承Thread类，然后主方法中创建线程，Thread t = new Processor();父类引用指向子类对象，然后t.start();

第二种是实现Runnable接口，实现run方法。
首先定义Processor实现Runnable接口，实现run方法，然后主方法创建线程，Thread t = new Thread(new Processor());将new Processor()对象传给Thread。然后t.start()。
推荐选择第二种。
因为一个类实现接口之外还保留了类的继承
7.线程的生命周期
新建
就绪
运行
阻塞
死亡/消亡

new表示新建状态
线程新建之后调用start方法进入就绪状态
就绪状态的线程表示有权利去获取CPU的时间片。CPU时间片是执行权。当线程拿到CPU时间片之后就马上执行run方法，这个时候就代表进入运行状态。（就绪状态和运行状态频繁切换）
阻塞事件导致运行到阻塞
阻塞解除导致阻塞到运行

线程的生命周期.jpg

8.线程的调度与控制
java虚拟机负责线程的调度，取得CPU的使用权。
目前两种调度模型：分时调度模型、抢占式调度模型
抢占式调度模型：优先级高的线程获取的时间片相对多一些，有时候也不一定
8.1线程优先级
1-10 默认是5
MAX_PRIORITY MIN_PRIORITY NOM_PRIORITY 最高级最低级默认

/**
 *线程优先级
 *  如何获得线程对象
 *
 */
public class test01 {
    public static void main(String[] args) {
        Thread t = Thread.currentThread();
        //static Thread currentThread()
        //返回对当前正在执行的对象的引用
        //t保存的的内存地址指向的线程是“主线程对象”
        System.out.println(t.getName());//main

        Thread t1 = new Thread(new Processor());
        t1.setName("t1");
        t1.start();//t1

        Thread t3 = Thread.currentThread();
        System.out.println(t3.getName()); //main

        Thread t2 = new Thread(new Processor());
        t2.setName("t2");
        t2.start();//t2
    }
}
class Processor implements Runnable {
    @Override
    public void run() {
        Thread t = Thread.currentThread();
        System.out.println(t.getName());
    }
}

/**
 *线程优先级
 *  如何获得线程对象
 *
 */
public class test01 {
    public static void main(String[] args) {
        Thread t = Thread.currentThread();
        //static Thread currentThread()
        //返回对当前正在执行的对象的引用
        //t保存的的内存地址指向的线程是“主线程对象”
        System.out.println(t.getName());//main

        Thread t1 = new Thread(new Processor());
        t1.setName("t1");

        Thread t2 = new Thread(new Processor());
        t2.setName("t2");

        t1.setPriority(10);
        t2.setPriority(1);
        t1.start();//t1
        t2.start();//t2
    }
}
class Processor implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

8.2
Thread.sleep();
sleep方法是一个静态方法
作用：阻塞当前线程，腾出CPU，让给其他程序

import static java.lang.Thread.*;

public class test01 {
    public static void main(String[] args) throws InterruptedException {
        
        Thread t = new Thread(new Processor());
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println(currentThread().getName() + "-->" + i);
            sleep(1000);
        }
    }
}

class Processor implements Runnable {
    @Override
    //老师讲的是继承Thread，下面的注释和我写的不一致，但是也会遇到同样的问题，为什么？？？？？
    //Thread中的run方法不抛出异常，所以重写run方法之后，在run方法的声明位置不能throws
    //只能try...catch...
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(currentThread().getName() + "-->" + i);
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//import static java.lang.Thread.currentThread;

public class test01 {
    public static void main(String[] args) throws InterruptedException {
        A a = null;
        a.m1();
        Thread.sleep(5000);
        System.out.println(Thread.currentThread().getName() + "Hello World");
        //System.out.println(currentThread().getName() + "Hello World");  这种写法需导入import static java.lang.Thread.currentThread;
        //我不知道为什么
    }
}
class A{
    public static void m1(){}
}

以上程序涉及到两个问题，一个待解决

t.interrupt();不是静态方法作用时结束睡眠

//import static java.lang.Thread.currentThread;

public class test01 {
    public static void main(String[] args) throws InterruptedException {
        boolean run = true;
        Processor p = new Processor();
        Thread t = new Thread(p);
        t.setName("T");

        t.start();

        Thread.sleep(5000);

        p.run = false;
    }
}

class Processor implements Runnable{
    boolean run = true;
    public void run(){
        long timeStart = System.currentTimeMillis();
        for(int i = 0; i < 10 && (System.currentTimeMillis() - timeStart) <= 5000; i++){//我用两种方式进行了控制
            System.out.println(Thread.currentThread().getName() + "-->" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
    }
}

Thread.yield
让位
她与sleep()类似，只是不能由用户指定暂时的时间，而且只能同优先级的线程让位，但是让位时间不固定。
和sleep()一样都是静态方法
线程的合并
t.join() 是成员的方法！！！！

8.3