【7.14/7.15】线程Thread

1）：进程的就绪（Runnable）和阻塞（Blocked）的区别

　　　　当处理机空闲时，处于就绪状态的线程就会得到处理器资源，进入运行，当调用yield()时，处于运行状态的线程转入就绪状态。

　　　　当线程陷入阻塞时，即使处理机空闲也不会为该进程分配处理器资源，直到相关的动作完成（sleep时间到、I/O输入完成，获得同步锁，收到通知

　　　　、resume()），sleep()、等待I/O输入，等待同步锁、等待通知、suspend()等会让进程进入阻塞状态。

 2):Lock和synchronized的区别

　　　　Lock是一个接口，需要使用其子类ReentrantLock可以创建对象

　　　　Lock需要手动上锁，包括上锁的时间和地点，上锁后需要手动解锁　　　

//Lock 的用法
public static Lock lock=new ReentrantLock();
public static Condition condition=lock.newCondition();
Test.lock.lock();
            try {
                    Test.condition.signal();
                     Test.condition.await();            
            } finally {
                Test.lock.unlock();
            }

//synchronized的用法
private Res res;//这个res是需要上锁的资源
synchronized (res) {
                res.notify();
                try {
                    res.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        }

 3）：信号量（Semaphore）的用法

//创建一个银行账户Account类，在创建并启动100个线程往同一个Account类实例里面添加一块钱
public static class Account{
    private static Semaphore semaphore = new Semaphore(1);  //创建一个信号量
    private int balance =0;
    public int getBalance(){
        return balance;
    }
    public  void deposit(int amount){
        try {
            semaphore.acquire();
            int newBalance = balance + amount;
            Thread.sleep(4);   
            balance= newBalance;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            semaphore.release();   //返回一个信号量
        }
    }
}