Java中基础进程和线程知识个人总结

基础进程和线程知识个人总结

目录：

1.进程和线程
2.并发和并行
3.线程的创建和执行方法
4.为什么在main中要用start方法去启动线程，而不是直接调用dog类的run方法？
5.继承Thread实现类和实现Runnable接口的区别
6.线程插队方法join方法
7.守护线程setDaemon方法
8.线程安全中的互斥锁synchronized属性
9.线程死锁
10.同步中自动释放锁的情况
11.同步中不会释放锁的情况
12.线程的七大状态图

1.进程和线程：

• 进程：进程是指一个运行中的程序，比如打开一个qq，则这个qq就是一个进程，
  一个进程会分配一定的内存空间，是动态过程，有自身的产生，存在，消亡的过程。
• 线程：线程由进程创建，比如qq进程打开一个新的聊天页面，迅雷产生一个新的下载，是进程的一个实体，
  一个线程可以执行多个线程。

2.并发和并行：

• 并发： 并发是指一个单核cpu每次只能执行一个任务，但是任务之间相互交替执行，造成其几个任务同时执行的假象，
  如某个时刻，由QQ切换到迅雷，其中QQ和迅雷好像同时进行一样的。

• 并行： 并行是指同一时刻，多个任务同时执行， 即多核cpu，每个核执行一个任务，多核cpu实现多任务并行，但是每个核也可以实现任务并发执行。

3.线程的创建和执行方法：

• 继承：

  1. 可以让dog类继承Thread实现类，dog类中重写Thread中的run方法，将要执行的代码写在run方法中，
  2. 然后直接在main方法中新建dog类对象创建这个dog类的一个线程（直接new这个类的对象），然后执行线程中的start方法（Thread中的start方法），其底层是执行start0方法（本地方法，用于去调用类的run方法）。

• 实现：

  1. 也可以让dog类去实现Runnable接口，dog类中重写Runnable的run方法，将要执行的代码写在run方法中，
  2. 然后在main方法中新建这个dog类的对象，
  3. 因为是dog类是直接实现Runnable接口，Runnable接口中没有start方法，所以需要一个代理类（Thread实现类），新建Thread实现类，将这个dog类对象当作参数，这样就创建了这个dog类的一个线程，然后使用这个线程的start方法（Thread中的start方法），其底层也是执行start0方法（本地方法，用于去调用类的run方法）。

4.为什么在main中要用start方法去启动线程，而不是直接调用dog类的run方法？：

• 如果是在main方法中直接调用dog类的run，这个代码的执行顺序就是串行化执行，会等调用的run方法执行完后才执行main方法在调用run方法后的剩余代码，即在run方法的地方造成阻塞。
• 如果是使用start方法，他会在底层start0方法中去调用run方法，但是此时main方法在start方法后面的剩余代码也还在执行，它们是并发的交替的去执行，不会造成阻塞。

5.继承Thread实现类和实现Runnable接口的区别：

• 继承Thread类的对象，每需要创建一个线程，就要重新创建一个对象，没有体现出共享同一对象资源（属性和方法等）（除开static修饰的属性和方法）
• 实现Runnable接口，创建一个对象，然后可以使用多个线程代理，即多线程机制，可以同时共享同一对象资源（属性和方法等）。

6.线程插队方法join方法
原理：如果使用了线程插队join方法，会先等插队的这个线程执行完后才执行插队方法后的剩余代码。

7.守护线程setDaemon方法
原理：当一个线程被守护后，一旦这个线程结束，那么守护这个线程的哪个守护线程也自动结束，不管它有没有执行完。

8.线程安全中的互斥锁synchronized属性
代码上锁后这样执行的效率较低，代码范围越小，执行效率越高。
这里资源默认是static的，继承的Thread实现类条件下

• synchronized属性在代码块前
  对象这里锁默认指的是this类本身的同一对象，才能使同一个对象的一个一个的线程执行，
  1. 如果是不同对象（继承Thread实现类方式），默认的情况下，互斥锁锁不住，这时候的不同对象的线程会单个执行到这个方法中执行，共同执行这个方法
  2. 如果是不同对象（继承Thread实现类方式），传入相同参数作为锁的对象，互斥锁也能锁住。
  3. 同一对象的不同线程才能锁住。（实现Runnable接口）
     一般建议使用同步代码块方法加同步synchronized锁！且不能直接加在run方法上！

synchronized(对象){

}

• synchronized属性在方法中：互斥锁也是默认在this对象上。只能同一对象的不同线程才能锁住。（实现Runnable接口）

public synchronized void sell(){

}

• synchronized属性在方法属性static前，就代表这把锁加在这个类的字节码文件中。

9.线程死锁

public class Demo {


    public static void main(String[] args) {
        Cat cat = new Cat(0);
        cat.start();
        Cat cat1 = new Cat(1);
        cat1.start();
    }
}

public class Cat extends Thread{
    int num;
    static Object o1= new Object();
    static Object o2= new Object();


    public Cat(int num) {
        this.num = num;
    }

    //发生死锁，抢夺共享变量资源，线程1抢住o1，但是执行下一步需要有o2资源，
    //但是o2资源已经被线程2拿走了，并且线程2执行下一步需要o1资源，
    @Override
    public void run() {
        switch (num){

            case 0:
                synchronized (o1){
                    System.out.println("进入0的1");
                    synchronized (o2){
                        System.out.println("进入0的2");
                    }
                }
                break;
            case 1:
                synchronized (o2){
                    System.out.println("进入1的1");
                    synchronized (o1){
                        System.out.println("进入1的2");
                    }
                }
                break;
        }
    }
}

10.同步中自动释放锁的情况

• 同步代码块执行完，自动释放锁对象
• 同步代码块中遇到break,return，自动释放锁对象
• 同步代码块中，出现异常，自动释放锁对象
• 同步代码块中，出现wait()方法，线程暂停，自动释放锁对象

11.同步中不会释放锁的情况

• 调用了Thread.sleep()方法，睡眠了，不会释放锁
• 遇到suspend()方法，将该线程挂起，不会释放锁

12.线程的七大状态图