2021-8-2进程与线程复习

进程与线程

进程就是正在运行的程序，他代表了程序所占用的内存区域

独立性：进程是系统中独立存在的实体，它可以拥有自己独立的资源，每一个进程都拥有字节私有的地址空间，在没有经过进程本允许的情况下，一个用户进程不可以直接访问其他进程的地址空间

动态性：进程与程序的区别在于，程序是一个静态的指令集合，而进程是一个正在系统中活动的指令集合，程序加入了时间的概念以后，称为进程，具有自己的生命周期和各种不同的状态，这些概念都是程序所不具备的

并发性：多个进程可以在单个处理器CPU上并发执行，多个进程直接不会互相影响

线程是操作系统能够进行运算调度的最小单位，他被包含在进程之中，是进程中实际运作单位，

一个进程可以开启若干多个线程，其中有一个线程来调用本进程中的其他线程

我们看到的进程的切换，切换得也是不同进程的主线程，一个操作系统中可以有多个进程，一个进程中可以包含一个线程，也可以包含多个线程

package cn.tedu.test1;
public class Thread1 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread("dd");
        MyThread myThread1 = new MyThread("t");
        MyThread myThread2 = new MyThread("tt");
        MyThread myThread3 = new MyThread("tty");
        myThread.start();
        myThread1.start();
        myThread2.start();
        myThread3.start();
    }
}
class MyThread extends Thread{
    public MyThread() {
    }
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(i+"="+getName());
        }
    }
}


package cn.tedu.test1;

public class Thread2 {
    public static void main(String[] args) {
        MyThread1 myThread1 = new MyThread1();
        Thread thread = new Thread(myThread1,"dd");
        Thread thread1 = new Thread(myThread1,"tt");
        Thread thread2 = new Thread(myThread1,"aa");
        Thread thread3 = new Thread(myThread1,"ss");
        thread.start();
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
class MyThread1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(i+Thread.currentThread().getName());
        }
    }
}

两种实现方式的比较

继承Thread类

优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this即可获得当前线程

缺点：自定义的线程类已继承了Thread类，所以后续无法再继续继承其他的了

实现Runnable接口

优点：自定义的线程类实现了Runnable接口或Callable接口，后续还可以继承其他类，在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将cpu，代码，还有数据分开（解耦），形成清晰的模型，较好的体现了面向对象的思想

缺点: 编程稍微复杂,如想访问当前线程,则需使用Thread.currentThread()方法

同步锁-线程安全问题解决方案

在多线程程序中+有共享数据+多条语句操作共享数据

同步：体现了排队的效果，同一时刻只能有一个线程独占资源，其他的没有权利的线程排队

缺点就是效率会降低，不过保证了安全。

异步：体现了多线程抢占资源的效果，线程间互相不等待，互相抢占资源。

坏处就是有安全隐患，效率要高一些

synchronized (锁对象){
需要同步的代码(也就是可能出现问题的操作共享数据的多条语句);
}

 改造售票案例

package cn.tedu.test1;
public class Thread3 {
    public static void main(String[] args) {
        MyThread2 myThread2 = new MyThread2();
        Thread thread = new Thread(myThread2, "☕");
        Thread thread1 = new Thread(myThread2, "🎂");
        Thread thread2 = new Thread(myThread2, "🐤");
        Thread thread3 = new Thread(myThread2, "🐢");
        thread.start();
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
class MyThread2 implements Runnable{
    static int ticket=1000;
    @Override
    public void run() {

            while (true) {
                synchronized (MyThread2.class) {
                    if (ticket>0) {
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + ticket--);
                    }
                if (ticket <= 0) break;
            }
        }
    }
}