线程的基础（上）

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

1、进程是什么？

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

2、线程又是什么？

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

二、他们之间的关系

1、一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程（通常说的主线程）。
2、资源分配给进程，同一进程的所有线程共享该进程的所有资源。
3、线程在执行过程中，需要协作同步（生产者消费者）。不同进程的线程间要利用消息通信的办法实现同步。
4、CPU是分给线程，即真正在CPU上运行的是线程。

三、并行和并发

并发：线程轮流使用 CPU 的做法
并行：多核 cpu下，每个核（core） 都可以调度运行线程

java中创建线程的方法

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

1、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) {
   MyThread myThread = new MyThread();
   //这不是启动一个线程，这是调用对象里面一个普通方法run()方法
   //myThread.run();
   //真正启动一个线程调用start()方法，执行的代码就是run()方法里面代码
   myThread.start();
}

2、Runnable

实现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();
}

3、生产者和消费者问题

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

对于同步和异步的控制都是在Panzi这个类里面进行的，是最核心的类，生产者和消费者只是不停的
生产蛋糕和吃蛋糕，不需要考虑线程的同步和异步，同步和异步的操作都是在Panzi这个类里面完成。
调用wait和notify/notifyAll都必须要加上synchronized。
什么时候使用wait和notifyAll：
这两个是成对出现的，我们在等待的是生产的Cake，没有Cake就wait，生产者生产了Cake之后就调用notifyAll。

多线程的编程步骤：
1、第一步：创建资源类,在资源类创建属性和操作方法（在这类Panzi就是资源类）
2、第二步：在资源类中操作方法 （Panzi里面有getCake()方法）
1、判断
2、业务代码（干活）
3、通知
3、第三步：创建多个线程，调用资源类的操作方法。 (生产者线程和消费者线程生产了蛋糕放到盘子panzi.putCake(),吃蛋糕panzi.getCake())
同步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;
}
/*
 * 资源类（核心类）,生产者线程ProducerThread生产了蛋糕调用putCake放到盘子里，
* 消费者线程ConsumerThread吃蛋糕就调用getCake从盘子里拿蛋糕

 */
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); //重写Thread类中的一个方法（含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);//便于这里输出name的值！
        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();
        }
     }
   }

}

线程共享一个资源，所以Main中的panzi，定义的list表也是公用一个。