进程和线程的关系与区别是什么？如何创建多线程？

单核CPU和多核CPU：
单核CPU：在一个时间单元内，只能执行一个线程的任务。是一种假的多线程。（单核CPU可以“挂起”一个线程，执行另一个线程，看起来像是多线程）
多核CPU：多线程。
一个Java应用程序java.exe，至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。如果发生异常，会影响主线程。

并行和并发：
并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU（采用时间片）"同时"执行多个任务。比如：秒杀，多个人做同一件事。
注：“同时”：其实是采用时间片的方式，执行一段A，再执行一段B，只不过时间比较短，看起来就像是同时进行一样。

进程与线程
程序(program)：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
**进程(process)：**是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程，有自身的产生、存在和消亡的过程。–生命周期
进程是资源分配的单位，系统在运行时为每个进程分配不同的内存区域。
**线程(thread)：**进程可进一步细化为线程，是一个程序内部的一条执行路径。
线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc),线程切换开销小；
一个进程中的多个线程共享相同的内存单元/内存地址空间，它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能会带来安全隐患。

进程和线程的关系：
1.一个进程至少有一个线程，可以包括多个线程，而一个线程只能属于一个进程。
2.一个进程中的多个线程共享该进程的内存空间即方法区和堆空间。
2.一个进程的崩溃在保护模式下不会对其他进程产生影响，但是一个线程崩溃会影响整个进程死掉。多进程的程序要比多线程的程序健壮性更强。

进程和线程的区别：
1.根本区别：进程是操作系统资源分配的基本单位；
线程是处理器任务调度和执行的基本单位。
2.资源开销：每个进程都有独立的代码可数据空间，程序之间的切换会产生较大的开销；
线程是轻量级的进程，线程共享代码可数据空间，每个线程都有自己独立的运行栈和程序计数器(pc)，线程切换开销小；
3.内存分配：系统在运行时为每个进程分配不同的内存区域；
而一个进程中的多个线程共享相同的内存单元/内存地址空间。
4.所处环境：在操作系统中可以同时运行多个进程，在一个进程中可以有多个线程同时执行。
5.执行过程：进程有程序运行的入口、顺序执行序列及程序出口；而线程不能独立运行，必须依赖于进程中。
6.包含关系：线程是进程的一部分，被称为轻量级进程。

-----------------------------------------------分割线------------------------------------------------------------
多线程的优点：
1.提高应用程序的响应，对图形化界面更有意义，可增强用户体验。
2.提高计算机系统CPU的利用率。
3.改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

什么时候需要多线程？
1.程序需要同时执行两个或多个任务。
2.程序需要实现一些等待的任务时，比如用户输入、文件读写操作、网络操作、搜索灯。
3.需要一些后台运行的程序时。

线程的创建和启动：
java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。

Thread类的特性：
1.每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主题称为线程体。
2.通过该Thread对象的start()方法来启动这个线程，而非直接调用run().

Thread类的相关常用方法：
1.start():启动当前线程；调用当前线程的run();
2.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中；
3.currentThread():静态方法：返回执行当前代码的线程；
4.getName():获取当前线程的名字；
5.setName():设置当前线程的名字；
6.yield():释放当前CPU的执行权；
7.join():在线程A中调用线程B的join(),此时线程A就进入阻塞状态，直到线程B完全执行完以后，线程A才结束阻塞状态；
8.stop():已过时。当执行此方法时，强制结束当前线程；
9.sleep(long millitime):让当前线程睡眠指定的的millitime毫秒。在指定的millitime时间内，当前线程是阻塞状态；
10.isAlive():判断当前线程是否存活。

线程的优先级：
1.MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5
2.如何获取和设置当前线程的优先级？
getPriority():获取线程的优先级
setPriority(int p):设置线程的优先级

tips：高优先级的线程要抢占低优先级线程CPU的执行权，但是从概率上讲，高优先级的线程高概率下会先被执行。
并不意味这只有当高优先级的线程执行完以后，低优先级的线程才会执行。

---------------------------------------------分割线----------------------------------------------------------------------------------------
多线程的创建
方式一：继承thread类
1.创建一个继承于thread类的子类;
2.重写thread类的run()–>将此线程执行的操作声明在run()中;
3.创建thread类的子类对象;
4.通过此对象调用start()：①启动当前线程;②调用当前线程的run().
eg:
子类MyThread Code:

//1.创建一个继承于thread类的子类;
class MyThread extends Thread{
    //2.重写thread类的run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+ ":" + i);
            }
        }
    }
}

Test Code:

public class ThreadTest {
    public static void main(String[] args) {
        //3.创建thread类的子类对象
        //main()的主线程 调用t1对象
        MyThread t1 = new MyThread(); //alt + Enter
        //4.通过此对象调用start():①启动当前线程;②调用当前线程的run()
        t1.start();//调用start(),执行run()之后，t1的分线程执行

        //tips1:启动一个线程，必须调用start(),不能通过直接调用run()的方式启动线程。
        //t1.run();//相当于只是在main()中调用run方法，并不是Thread中的run(),没有启动分线程

        //tips2:如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start();遍历100以内的偶数,不可以还让已经start()的线程去执行，会报 java.lang.IllegalThreadStateException
//        t1.start();
        //需要重新创建一个线程的对象
        MyThread t2 = new MyThread();
        t2.start();

        //仍然在main线程中执行，线程交互
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+ ":" + i + "******main()****************");
            }
        }
    }
}

tips1:启动一个线程，必须调用start(),不能通过直接调用run()的方式启动线程。
tips2:如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start();

创建多线程的方式二：实现Runnable接口
1.创建一个实现了Runnable接口的类;
2.实现类去实现Runnable中的抽象方法：run();
3.创建实现类的对象;
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象;
5.通过Thread类的对象调用start();

比较创建多线程的两种方式：
开发中我们优先选择：实现Runnable接口的方式;
原因：1.实现的方式没有类的单继承性的局限性;
2.实现的方式更适合来处理多个线程有共享数据的情况.
联系：public Thread implements Runnable{} Thread类本身实现了Runnable接口;
相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中.
启动线程都是调用Thread类中的start().

eg:创建三个窗口卖票，总票数100张，使用继承Thread类的方式

class Window extends Thread{
//    private int ticket = 100;//修改窗口1的票数，窗口2/3的没变
    private static int ticket = 100;//应该改为static，三个线程共享一个

    @Override
    public void run() {
        while(true){
            if(ticket > 0){
//                System.out.println(Thread.currentThread().getName());
                System.out.println(getName()+"卖票，票号为:"+ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}



public class WindowTest {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();//得new三个对象

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");//三个对象分别调用setName();

        w1.start();
        w2.start();
        w3.start();
    }
}

创建三个窗口卖票，总票数100张，使用实现Runnable接口的方式;

class Window1 implements Runnable{

    private int ticket = 100;//不用加static，本身共享数据

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "卖票:票号为" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();
//        Window1 w2 = new Window1();
//        Window1 w3 = new Window1();没必要new三个对象

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);//三个线程共享一个new出来的对象

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}