线程随笔记

线程创建方式

　　1、继承Thread类，主线程中 new 实现类().start()；线程名可以在子类构造方法中添加；

class Demo extends Thread {
   Demo(String name){
      super(name);    
   }  
  public void run(){
      ...  
  }
}

       2、实现Runnable接口，主线程中  new Thread (实现类对象，线程名).start()。

线程的状态

　　新生状态　　　线程对象创建好了，未调用 start 方法之前。就是 new Thread() 

　　就绪状态           线程在调用 start 方法之后，进入就绪状态（可运行状态）

　　运行状态　　    线程获得线程调度器的调度之后进入运行状态，CPU执行

　　阻塞状态　　    线程运行是调用了  join/sleep/wait  方法，进入阻塞状态

　　死亡状态        　线程执行结束

线程同步

　　synchronized代码块、synchronized方法、lock

　　同步代码块中可以使用任意锁。

　　同步方法中不指定锁，当不是静态方法时，锁是 this  ； 当是静态方法时 ，锁是 类的字节文件  class ，可以用 getClass() 获取，也可以用当前 类名.class() 

　　

　　lock 接口 ：将同步的隐式锁操作变成显式锁操作；condition 接口 ：将 wait , notify , notifyAll 方法进行封装，变成监视器对象，可以任意锁组合

　　Lock lock = new ReentrantLock();

　　Condition con = lock.newCondition();

　　lock.lock()   获取锁

　　lock.unlock()  释放锁，通常定义在 finally 代码块中

　　con.await()   等待，相当于wait();

　　con.signal()    相当于 notify

　　con.signalAll()   相当于 notifyAll.

　

wait 与 sleep

　　wait 进入等待，可以指定时间也可以不指定时间，会释放锁

　　sleep 进入睡眠，必须指定时间，不会释放锁

生产者与消费者

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProducterConsumer {

    public static void main(String[] args) {
        Resource r = new Resource();
        Produter p1 = new Produter(r);
        Produter p2 = new Produter(r);
        Cousumer c1 = new Cousumer(r);
        Cousumer c2 = new Cousumer(r);
        Thread t1 = new Thread(p1);
        Thread t2 = new Thread(p2);
        Thread t3 = new Thread(c1);
        Thread t4 = new Thread(c2);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

}

class Resource {
    private String name;
    private int count = 0;
    private boolean flag = false;
    Lock lock = new ReentrantLock();
    
    Condition prod_con = lock.newCondition();
    Condition cons_con = lock.newCondition();
    
    
    public void production(String name) {
        lock.lock();
        try {
            while(flag) {
                prod_con.await();　　　　//进入等待，释放锁
            }
            this.name = name + (++count);
            System.out.println(Thread.currentThread().getName() + "..生产了.." + this.name);
            flag = true;
            cons_con.signal();　　　　　　//生产完毕，唤醒其他线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    public void consumption() {
        lock.lock();
        try {
            while(!flag) {
                cons_con.await();　　　　//进入等待，释放锁
            }
            System.out.println(Thread.currentThread().getName() + ".....消费了....." + this.name);
            flag = false;
            prod_con.signal();　　　　　　//唤醒其他线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
}

class Produter implements Runnable{

    private Resource r;
    
    Produter(Resource r){
        this.r = r;
    }
    
    @Override
    public void run() {
        while(true)
            r.production("粉蒸肉");
    }
    
}

class Cousumer implements Runnable{

    private Resource r;
    
    Cousumer(Resource r){
        this.r = r;
    }
    
    @Override
    public void run() {
        while(true)
            r.consumption();
    }
    
}

如有错误的地方，请指出。谢谢评论。