进程、线程

目录

34. 进程、线程

● 进程和线程的定义

● 进程和线程之间的关系

● Java里面创建线程的两种方式

● synchronized（同步 加锁）

● 生产者和消费者问题

● Thread常用方法

● yield

● join

● 如何正确的停止线程

● 中断线程

---

34. 进程、线程

● 进程和线程的定义

1、进程是什么？

是具有一定独立功能的程序、它是系统进行资源（内存）分配和调度的一个独立单位，重点在系统调度和单独的单位，也就是说进程是可以独立运行的一段程序。

2、线程又是什么？

线程是进程的一个实体，是CPU调度和分派的基本单位，他是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源。

● 进程和线程之间的关系

1、一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程（通常说的主线程）。

2、资源分配给进程，同一进程的所有线程共享该进程的所有资源。

3、线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。

4、CPU是分给线程，即真正在CPU上运行的是线程。

5、线程是指进程内的一个执行单元，也是进程内的可调度实体。 

调度：进程作为拥有资源的基本单位，线程是作为CPU调度和分配的基本单位。

拥有资源：进程是拥有资源的独立单位，线程是不拥有系统资源，但是可以访问隶属于进程的资源。

---

● Java里面创建线程的两种方式

1、直接继承Thread

2、实现Runnable接口

两者最大区别就是，Java里面是单继承的，继承Thread类方式将单继承这个位置给占了，只能去实现接口，不能再去继承别的类了，而实现Runnable接口这种方式不影响继承类也不影响实现其他接口。

//直接继承Thread
public class MyThread extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}

//
public static void main(String[] args) {
        // new线程这个对象，并不是启动线程，只是new了一个线程的对象
        MyThread myThread = new MyThread();
        // 这是调用对象的run方法执行，不是启动线程
        // myThread.run();
        myThread.start();
    }

//实现Runnable接口
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
        }
    }
}

//
public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }

---

● synchronized（同步 加锁）

Synchronized加了锁之后其他线程就不能访问了，除非释放这个锁。

---

● 生产者和消费者问题

名字	说明
Cake	蛋糕类
Panzi	蛋糕的队列
ProducerThread	生产蛋糕的线程
ConsumerThread	消费蛋糕的线程
Main	测试类

Sequence序列图：

对于同步和异步的控制都是在Panzi这个类里面进行的，是最核心的类，生产者和消费者只是不停的生产蛋糕和吃蛋糕，不需要考虑线程的同步和异步，同步和异步的操作都是在Panzi这个类里面完成。

调用wait和notify/notifyAll都必须要加上synchronized。

notify和notifyAll都可以完成通知，notify控制比较复杂，我们直接使用notifyAll就可以。

什么时候使用wait和notifyAll：

这两个是成对出现的，我们在等待的是生产的Cake，没有Cake就wait，生产者生产了Cake之后就调用notifyAll。

同步（synchronized）：A叫B去干活，A等着B干完之后才去干活

异步（asynchronized）：A叫B去干活之后，A还可以继续干自己活，B干完了要通知A

 Cake.java

public class Cake {
    // 蛋糕的编号
    private String name;

    public Cake() {
    }

    public Cake(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Cake{" +
                "name='" + name + '\'' +
                '}';
    }
}

Panzi.java

public class Panzi {
    // 只在头部移除removeFirst，只在尾部添加addLast
    private LinkedList<Cake> list = new LinkedList<>();

    public synchronized void putCake(Cake cake) {
        // 在队列的尾部添加
        list.addLast(cake);
        notifyAll();// 生产了蛋糕之后通知正在wait的消费者线程去吃这些蛋糕
        System.out.println("生产者线程 putCake notifyAll");
    }

    // 在wait和notifyAll上都要加上synchronized
    public synchronized Cake getCake() {
        if (list.size() <= 0) { // 盘子里面没有蛋糕了，所以要wait等待
            try {
                System.out.println("消费者线程 getCake  wait");
                wait();// 盘子里面没有蛋糕，需要等待生产者生产蛋糕
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 队列头部删除
        Cake cake = list.removeFirst();
        return cake;
    }
}

 ConsumerThread.java 

public class ConsumerThread extends Thread{
    private Panzi panzi;

    public ConsumerThread(String name, Panzi panzi) {
        super(name);
        this.panzi = panzi;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 1000; i++) {
            Cake cake = panzi.getCake();
            System.out.println(Thread.currentThread().getName() + " getCake : " + cake);

            // 生成随机等待的时间，模拟吃蛋糕的过程
            try {
                Thread.sleep(new Random().nextInt(5000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 ProducerThread.java

public class ProducerThread extends Thread{
    private Panzi panzi;

    public ProducerThread(String name, Panzi panzi) {
        super(name);
        this.panzi = panzi;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 1000; i++) {
            Cake cake = new Cake("no：" + i);
            System.out.println(Thread.currentThread().getName() + " putCake : " + cake);
            // 生产了一个蛋糕就放到盘子里面
            panzi.putCake(cake);

            // 1000毫秒是1秒
            // 生成随机等待的时间，模拟生产蛋糕的过程
            try {
                Thread.sleep(new Random().nextInt(5000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
        // 生产者和消费者操作的是同一个盘子
        Panzi panzi = new Panzi();
        // 启动生产者线程去生产蛋糕
        ProducerThread producerThread = new ProducerThread("生产者线程",panzi);
        producerThread.start();
        // 启动消费者线程去吃蛋糕
        ConsumerThread consumerThread = new ConsumerThread("消费者线程", panzi);
        consumerThread.start();
    }
}

---

---

● Thread常用方法

让线程暂时停止可以选择sleep方法。比如Thread.sleep(1000),当前线程睡眠1秒。需要知道的是，1秒后，线程是回到可执行状态，并不是执行状态，什么时候执行那是由虚拟机来决定的。所以sleep(1000)并不是在睡眠1秒后立即执行。

---

● yield

解释它之前，先简述下，多线程的执行流程：多个线程并发请求执行时，由cpu决定优先执行哪一个，即使通过thread.setPriority()，设置了线程的优先级，也不一定就是每次都先执行它

Thread.yield();，表示暂停当前线程，执行其他线程(包括执行yield这个线程)， 执行谁由cpu决定

yield这个方法是让当前线程回到可执行状态，以便让具有相同优先级的线程进入执行状态(包括这个执行yield的线程，因为其也在可执行状态)

public static native void yield();

- Yield是一个静态的原生(native)方法

- Yield告诉当前正在执行的线程把运行机会交给线程池中拥有相同优先级的线程。

- Yield不能保证使得当前正在运行的线程迅速转换到可运行的状态

- 它仅能使一个线程从运行状态转到可运行状态，而不是等待或阻塞状态

---

● join

在某些情况下，如果子线程里要进行大量的耗时的运算，主线程可能会在子线程执行完之前结束，但是如果主线程又需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()。

阻塞所在线程，等调用它的线程执行完毕，再向下执行

a.join，在API中的解释是，在B线程中调用a.join()，堵塞当前线程B，直到A执行完毕并死掉，再执行B。

线程实例的方法join()方法可以使得一个线程在另一个线程结束后再执行。如果join()方法在一个线程实例上调用，当前运行着的线程将阻塞直到这个线程实例完成了执行

//Waits for this thread to die.

public final void join() throws InterruptedException

在join()方法内设定超时，使得join()方法的影响在特定超时后无效。当超时时，主方法和任务线程申请运行的时候是平等的。然而，当涉及sleep时，join()方法依靠操作系统计时，所以你不应该假定join()方法将会等待你指定的时间。

像sleep,join通过抛出InterruptedException对中断做出回应。

public class JoinExample {
    public static void main(String[] args) throws InterruptedException {
        /*new Thread(new Runnable() {
            @Override
            public void run() {

            }
        }).start();*/

        Thread t1 = new Thread(new Runnable() {
            public void run() {
                System.out.println("First task started");
                System.out.println("Sleeping for 2 seconds");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("First task completed");
            }
        });
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                System.out.println("Second task completed");
            }
        });
        t1.start();
        t1.join(); // Main线程等待t1线程执行完毕，在执行下面的操作
        t2.start();
    }
}


//Output:
//First task started
//Sleeping for 2 seconds
//First task completed
//Second task completed

---

---

● 如何正确的停止线程

java中有三种停止线程方法

1)使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。

2）使用stop方法方法强行终止线程，但是不推荐使用这个方法，应为stop不安全而且已经被废弃的方法，还有suspend和resume都是废弃的方法。

3）使用interrupt方法中断线程。

interrupt()方法 仅仅使线程中打了一个停止的标记，并不是真的停止线程。

this.interrupted() 测试当前线程是否已经中断。

this.isInterrupted()测试线程是否已经中断。

● 中断线程

线程的thread.interrupt()方法是中断线程，将会设置该线程的中断状态位，即设置为true，之后的结果：线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序本身，并不是一定中断这个线程。线程会不时地检测这个中断标示位，以判断线程是否应该被中断（中断标示值是否为true）。