1. 描述下并行和并发的区别。
并发:当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程,它只能把CPU运行时间划分成若干个时间段,
再将时间 段分配给各个线程执行,在一个时间段的线程代码运行时,其它线程处于挂起状。.这种方式我们称之为并发(Concurrent)。
并行:当系统有一个以上CPU时,则线程的操作有可能非并发。当一个CPU执行一个线程时,另一个CPU可以执行另一个线程,
两个线程互不抢占CPU资源,可以同时进行,这种方式我们称之为并行(Parallel)。
区别:并行是指两个或者多个事件在同一时刻发生;而并发是指两个或多个事件在同一时间间隔内发生。
举个例子:
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(); } }