线程的相关知识、JAVA实现死锁、生产者消费者问题

线程有五种状态：创建、就绪、运行、阻塞、结束

isAlive:判断线程是否活着。就绪、运行、阻塞是活着，创建、结束是死了

getPriority、setPriority:设置优先级，明显的是，优先级高的，cpu分的时间片多一点

sleep：Thread.sleep(毫秒) 让当前线程休眠多少毫秒

join:合并两个线程，当执行到这个方法的时候，等当前线程执行完，再执行主线程。

yield:当某个线程正在cpu执行的时候，遇到这个方法，让出一次当前的cpu给其他的线程使用。

Object的wait:获得当前对象锁的线程阻塞；

Object的notify/notifyAll:唤醒在当前对象阻塞的其他线程；

一、死锁的java实现

package ss;

public class TestDeadLock implements Runnable{

       public int flag = 1;

       static Object o1 = new Object(),o2 = new Object();

       public void run(){

      System.out.println("flag="+flag);

      if(flag==1){

                      synchronized(o1){

                            try {

                                      Thread.sleep(500);

                            } catch (InterruptedException e) {

                                       e.printStackTrace();

                            }

                           synchronized(o2){

                                    System.out.println("1");

                            }

                       }

                 }

             if(flag==0){

                     synchronized(o2){

                              try {

                                       Thread.sleep(500);

                              } catch (InterruptedException e) {

                                       e.printStackTrace();

                              }

                              synchronized(o1){

                                   System.out.println("0");

                      }

              }

          }

       }

       public static void main(String[] args){

              TestDeadLock td1 = new TestDeadLock();

              TestDeadLock td2 = new TestDeadLock();

              td1.flag = 1;

              td2.flag = 0;

              Thread t1 = new Thread(td1);

              Thread t2 = new Thread(td2);

              t1.start();

              t2.start();

       }

}

二、生产者消费者的java实现

package ss;

public class ProducerConsumer {

    public static void main(String[] args){

    Basket basket = new Basket();

    Producer p = new Producer(basket);

    Producer p2 = new Producer(basket);

    Producer p3 = new Producer(basket);

    Consumer c = new Consumer(basket);

    Consumer c2 = new Consumer(basket);

    Consumer c3 = new Consumer(basket);

    Thread tp = new Thread(p);

    Thread tp2 = new Thread(p2);

    Thread tp3 = new Thread(p3);

    Thread tc = new Thread(c);

    Thread tc2 = new Thread(c2);

    Thread tc3 = new Thread(c3);

    tp.setName("生产者1号");

    tp2.setName("生产者2号");

    tp3.setName("生产者3号");

    tc.setName("消费者1号");

    tc2.setName("消费者2号");

    tc3.setName("消费者3号");

    tp.start();

    tp2.start();

    tp3.start();

    tc.start();

    tc2.start();

    tc3.start();

    }

}

//生产的食物

class Food{

    int id;

    public Food(int id){

        this.id = id;

    }

    public String toString(){

        return id+"";

    }

}

//装食物的篮子，以栈的形式呈现

class Basket{

    int index = 0;//栈顶

    Food[] foods = new Food[6];//篮子里最多装6个馒头

    //生产食物

    public synchronized void push(Food food){

        //如果篮子里已经放满，阻塞当前线程

        while(index == foods.length){

            try {

                this.wait();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

        this.notifyAll();

        //放入篮子里

        foods[index] = food;

        index ++;

    }

    //消费食物

    public synchronized Food pop(){

        //如果篮子里是空的，阻塞当前线程.后面的代码不再执行。失去对象锁。

        while(index == 0){

            try {

                this.wait();

            } catch (InterruptedException e) {

            e.printStackTrace();

            }

        }

        //唤醒其他等待该对象的线程（无法唤醒自己，只有别人能唤醒自己。因为当前对象已经被锁定。唤醒只是将其他阻塞的          线程到就绪状态，等当前线程执行完毕，都回到同一起跑线）

       this.notifyAll();

       //从篮子里拿出来吃

       index -- ;

       Food food = foods[index];

       return food;

    }

}

//生产者生产食物过程

class Producer implements Runnable{

    Basket basket = null;

    public Producer(Basket basket){

        this.basket = basket;

    }

    //每次生产20个食物

    public void run(){

        for(int i=1;i<=20;i++){

            Food food = new Food(i);

            basket.push(food);

            System.out.println(Thread.currentThread().getName()+"生产食物:"+food);

            //生产一个休息会儿

            try {

                Thread.sleep((int)Math.random()*100);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

         }

      }

}

//消费者消费食物过程

class Consumer implements Runnable{

    Basket basket = null;

    public Consumer(Basket basket){

        this.basket = basket;

     }

     //消费20个食物

     public void run(){

         for(int i=1;i<=20;i++){

             Food food = basket.pop();

             System.out.println(Thread.currentThread().getName()+"消费了食物："+food);

             //消费完休息一会

             try {

                 Thread.sleep(1000);

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

         }

    }

}