java 线程(二)

1. 描述下并行和并发的区别。

　　并发：当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程，它只能把CPU运行时间划分成若干个时间段,

　　　　　　再将时间段分配给各个线程执行，在一个时间段的线程代码运行时，其它线程处于挂起状。.这种方式我们称之为并发(Concurrent)。

　　并行：当系统有一个以上CPU时,则线程的操作有可能非并发。当一个CPU执行一个线程时，另一个CPU可以执行另一个线程，

　　　　　　两个线程互不抢占CPU资源，可以同时进行，这种方式我们称之为并行(Parallel)。

　　区别：并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔内发生。

举个例子：

　　你吃饭吃到一半，电话来了，你一直到吃完了以后才去接，这就说明你不支持并发也不支持并行。

　　你吃饭吃到一半，电话来了，你停了下来接了电话，接完后继续吃饭，这说明你支持并发。（不一定是同时的）

　　你吃饭吃到一半，电话来了，你一边打电话一边吃饭，这说明你支持并行。

2.描述下线程的生命周期

Java线程具有五中基本状态

新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();

就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。

　　根据阻塞产生的原因不同，阻塞状态又可以分为三种：

　　　　1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

　　　　2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

　　　　3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

3.线程中的等待和通知机制

　　　　1. 调用wait（）方法之后，当前线程进入休眠状态并释放锁。

　　　　2. notify() 方法任意从 WAITTING 状态的线程中挑选一个进行通知（唤醒），使得调用wait（）的方法的线程从等待队列移入到同步队列中，等待有机会再一次获取到锁，

　　　　　　调用通知后，当前线程不会马上释放该对象锁，要等到程序退出同步块后，当前线程才会释放锁。

　　　　　　notifyAll使所有原来在该对象上等待的线程统统退出WAITTING状态。

注意： 1. 如果调用wait（）和 notify() 方法之前，线程必须要获得该对象的对象监视器锁，则会抛出IllegalMonitorStateException异常。

2. 实例化一个lock , 使用wait和notify的时候一定要配合synchronized关键字去使用，这都验证了 wait（）和 notify() 方法 只能在同步方法或同步块中调用。

　　　　3. Condition的作用是对锁进行更精确的控制。

　　　　　Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法。

　　　　 不同的是，Object中的wait(),notify(),notifyAll()方法是和"同步锁"(synchronized关键字)捆绑使用的；而Condition是需要与"互斥锁"/"共享锁"捆绑使用的。

参考：http://www.cnblogs.com/skywang12345/p/3496716.html

下面案例是：生产者和消费者模式

package cm.生产者和消费者模式;
/*  资源类(资源池)
 * 1.当消费者消费的资源不够时，通知生产者生产，消费者处于等待状态
 * 2.当生产者生产的资源饱和时，通知消费者消费，生产者处于等待状态
 */
public class Resource {
    private int num;  //表示当前资源量
    private int size = 20;//表示资源池的大小（饱和状态）
//表示消费了一个资源
    public synchronized void remove(){
        if(num>0){
            num--;
            System.out.println(Thread.currentThread().getName()+"消费了一件资源，剩余"+num+"件");
　　　　　　　　this.notify();
        }else{
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
        }
        
    }
    public synchronized void add(){
        if(num<size){
            num++;
            System.out.println(Thread.currentThread().getName()+"生产了一件资源，剩余"+num+"件");
            this.notify();//通知消费者消费
        }else{
            try {
                this.wait();//当资源的数量处于饱和状态生产者处于等待状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
    }
}

package cm.生产者和消费者模式;

public class CustomerRunnable implements Runnable {
    Resource res;
    public CustomerRunnable(Resource res){
        this.res =  res;
    }
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            res.remove();
        }
    }
}


package cm.生产者和消费者模式;

public class ProducerRunnable implements Runnable{
    Resource res;
    public ProducerRunnable(Resource res){
        this.res =  res;
    }
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            res.add();//表示让生产者生产
        }
        
    }
}

package cm.生产者和消费者模式;

public class Test {

    public static void main(String[] args) {
        Resource res  = new Resource();//创建资源类
        ProducerRunnable pr  = new ProducerRunnable(res);//生产者
        CustomerRunnable cr = new  CustomerRunnable(res);//消费者
        Thread pr1 = new Thread(pr,"生产者A");//生产者线程
        Thread pr2 = new Thread(pr,"生产者B");
        
        Thread cr1 = new Thread(cr,"消费者1号");//消费者线程
        Thread cr2 = new Thread(cr,"消费者2号");
        
        pr1.start();
        pr2.start();
        cr1.start();
        cr2.start();
    }

}

下面案例是使用 juc锁 condition 来解决存钱和取钱案例

package cm.await_signal_lock;

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

public class Account {
    private double money;//银行账户余额
    private ReentrantLock lock = new ReentrantLock();
    Condition con1 = lock.newCondition();
    
    public double getMoney() {
        return money;
    }
    public void setMoney(double money) {
        this.money = money;
    }
    public void saveMoney(double money){
            lock.lock();
            if(this.money > 0){
                try {
                    con1.await();//通知存钱线程处于等待状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                this.money+=money;
                System.out.println("存钱："+money);
            }
            
            con1.signal();//通知等待的取钱线程进行取钱
            lock.unlock();        
    }
    public  void fetchMoney(double money){
        lock.lock();
            if(this.money > 0){
                this.money-=money;
                System.out.println("取钱"+money);
                con1.signal();//通知等待的存钱线程进行存钱
            }
            try {
                con1.await();//当账户没钱了,让取钱线程处于等待状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        lock.unlock();    
    }
}

public class FetchMoneyRunnable implements Runnable{
    
    Account acc;//银行账户对象
    public FetchMoneyRunnable(Account acc) {
        this.acc = acc;
    }
    
//模拟账户取钱10次    
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            acc.fetchMoney(500);//取钱操作
        }        
    }
}



public class SaveMoneyRunnable implements Runnable{
    
    Account acc;
    public SaveMoneyRunnable(Account acc) {
        this.acc = acc;
    }

// 模拟存钱10次
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            acc.saveMoney(1000);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Account acc = new Account();//创建一个账户
        FetchMoneyRunnable fmr = new FetchMoneyRunnable(acc);
        SaveMoneyRunnable smr = new SaveMoneyRunnable(acc);
        Thread fetch = new Thread(fmr);//取钱线程
        Thread save = new Thread(smr);//存钱线程
        
        //启动线程
        fetch.start();
        save.start();
    }
}