线程1 进程和线程

进程、线程：

一、关于进程和线程，首先从定义上理解就有所不同

1、进程是什么？

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

2、线程又是什么？

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

二、他们之间的关系

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

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

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

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

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

————————————————

多线程同步和互斥的几种实现方式

1. 线程同步:

        指线程之间所具有的一种制约关系，一个线程的执行依赖另外一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒。

2. 线程互斥:

        指对于共享的进程系统资源，每个线程访问时的排他性。当有若干个线程都要使用某一个共享资源时，任何时刻最多只允许一个线程去使用，其他线程必须等待，知道占用占用资源者释放该资源。线程互斥可以看成是一种特殊的线程同步。

3. 线程间的同步方法大体可以分为两类:

        用户模式和内核模式

                a 用户模式：原子操作，临界区

                        临界区（Critical Section）：适合一个进程内的多线程访问公共区域或代码段时使用

                b 内核模式：事件、信号量、互斥量

                        事件（Event）：通过线程间触发事件实现同步互斥

                        互斥量 (Mutex)：适合不同进程内多线程访问公共区域或代码段时使用，与临界区相似

                        信号量（Semaphore）：与临界区和互斥量不同，可以实现多个线程同时访问公共区域数据，原理与操作系统中PV操作类似，先设置一个访问公共区域的线程最大连接数，每有一个线程访问共享区资源数就减一，直到资源数小于等于零

                内核模式就是利用系统内核对象的单一性来进行同步，使用时需要切换内核态与用户态，而用户模式就是不需要切换内核态，只在用户态完成操作

进程与线程的区别：

（1）调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位

（2）并发性：不仅进程可以并发执行，同一个进程的多个线程之间也可以并发执行

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

（4）系统开销：在创建或撤销进程时，由于系统要为之分配和回收资源，导致系统的开销明显大于创建或撤销时进程的开销

---

Java里面创建线程有两种方式：

1、直接继承Thread

2、实现Runnable接口

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

影响实现其他接口。

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) {

   MyThread myThread = new MyThread();

   //这不是启动一个线程，这是调用对象里面一个普通方法run()方法

   //myThread.run();

   //真正启动一个线程调用start()方法，执行的代码就是run()方法里面代码

   myThread.start();

}

实现Runnable接口方式：

public class MyRunnable implements Runnable{

   @Override

   public void run() {

     for (int i = 0; i < 100; i++) {

        System.out.println(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

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();

   }

}

public class Cake {

   // 蛋糕的编号

   private String name;

}

/*

 * 核心类，生产的蛋糕放到盘子里面，吃的蛋糕从盘子里面取

 */

public class Panzi {

   //使用LinkedList来模拟队列的操作，队列尾部添加，队列头部删除

   private LinkedList<Cake> list = new LinkedList<>();

   /*

    * 生产了蛋糕放到盘子里面

    */

   public synchronized void putCake(Cake cake) {

     //在队列尾部添加蛋糕

     list.addLast(cake);

     notifyAll();//生产了蛋糕之后要通知正在wait的ConsumerThread这些消费者

     System.out.println("生产者线程 putCake notifyAll");

   }

   

   /*

    * 从盘子里面拿出蛋糕吃

    */

   public synchronized Cake getCake() {

     if (list.size() <= 0) {//盘子里面没有蛋糕

        try {

           System.out.println("消费者线程 getCake  wait");

          wait();//盘子里面没有蛋糕，需要等待生产者生产蛋糕

        } catch (InterruptedException e) {

          e.printStackTrace();

        }

     }

     //队列头部删除

     Cake cake = list.removeFirst();

     return cake;

   }

}

/*

 * 消费者线程

 */

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();

        }

     }

   }

}

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);

        try {

          //生成随机等待的时间，模拟生成蛋糕需要时间

          Thread.sleep(new Random().nextInt(5000));

        } catch (InterruptedException e) {

          e.printStackTrace();

        }

     }

   }

}

生产者线程 putCake: Cake [name=no: 1]

消费者线程 getCake  wait

生产者线程 putCake notifyAll

消费者线程 getCake: Cake [name=no: 1]

消费者线程 getCake  wait

生产者线程 putCake: Cake [name=no: 2]

生产者线程 putCake notifyAll

消费者线程 getCake: Cake [name=no: 2]

消费者线程 getCake  wait

生产者线程 putCake: Cake [name=no: 3]

生产者线程 putCake notifyAll

消费者线程 getCake: Cake [name=no: 3]

生产者线程 putCake: Cake [name=no: 4]

生产者线程 putCake notifyAll

生产者线程 putCake: Cake [name=no: 5]

---

---

---

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

---

---

yield：

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

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

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

public static native void yield();//java里面执行进程线程要依靠操作系统里面的进程线程  native是C/C++里面的代码

- 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对中断做出回应。

join()方法使用示例

public class JoinExample {

   public static void main(String[] args) throws InterruptedException {

      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）。