黑马程序员_多线程二

------- android培训、java培训、期待与您交流！ ---------

一、线程的死锁：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放，由于线程被无限期地阻塞，因此程序不可能正常终止，造成了死锁。导致死锁的根源在于不适当地运用“synchronized”关键词来管理线程对特定对象的访问。“synchronized”关键词的作用是，确保在某个时刻只有一个线程被允许执行特定的代码块，因此，被允许执行的线程首先必须拥有对变量或对象的排他性的访问权。当线程访问对象时，线程会给对象加锁，而这个锁导致其它也想访问同一对象的线程被阻塞，直至第一个线程释放它加在对象上的锁,这个时候，就要防止多个线程同时访问共享资源，为了防止同时访问共享资源，线程在使用资源的前后可以给该资源上锁和开锁。给共享变量上锁就使得 Java 线程能够快速方便地通信和同步。某个线程若给一个对象上了锁，就可以知道没有其他线程能够访问该对象。即使在抢占式模型中，其他线程也不能够访问此对象， 直到上锁的线程被唤醒、完成工作并开锁。那些试图访问一个上锁对象的线程通常会进入睡眠状态，直到上锁的线程开锁。一旦锁被打开，这些睡眠进程就会被唤醒 并移到准备就绪队列中。
二、java中的等待唤醒机制：wait(),notify(),notifyAll()，这些方法都用在同步中，因为要对持有监视器（锁）的线程操作，只有同步才具有锁（因为这些方法只能用在同步中），这些方法都定义在Object类中，这些方法在操作同步中线程时，都必须要标识他们所操作线程只有锁，因为只有在同一个锁上的被等待线程，可以被同一个锁上的notify（）唤醒，不可以对不同锁中的线程进行唤醒；也就是说等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中

生产者和消费者示例

定义共享资源Things

public class Things { private String name; private String sex; private boolean flag=false; public synchronized void put(String name,String sex) { if(flag) try { //等待对方释放资源 wait(); } catch(Exception e) { e.printStackTrace(); } this.name=name; /*try { Thread.sleep(1); } catch(Exception ex) { ex.printStackTrace(); }*/ this.sex=sex; flag=true; //释放锁 notify(); } public synchronized void out() { if(!flag) try { //等待对方释放资源 wait(); } catch(Exception e) { e.printStackTrace(); } System.out.println("取出的数据为："+this.name+":"+this.sex); flag=false; notify(); } } //定义生产者线程

public class Product implements Runnable { Things th; public Product(Things th) { this.th=th; } int i=0; public void run() { while(true) { if(i==0) { th.put("张三", "男"); } else { th.put("lisi", "女"); } i=(i+1)%2; } } }

//定义消费者线程

public class Consumer implements Runnable{ Things th; public Consumer(Things th) { this.th=th; } public void run() { while(true) { th.out(); } } }

}

//测试示例代码

public class ThreadTest { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Things th=new Things(); Product pro=new Product(th); Consumer con=new Consumer(th); new Thread(pro).start(); new Thread(con).start(); } }

运行结果为：

取出的数据为：张三:男
取出的数据为：lisi:女
取出的数据为：张三:男
取出的数据为：lisi:女
取出的数据为：张三:男
取出的数据为：lisi:女
取出的数据为：张三:男
取出的数据为：lisi:女
取出的数据为：张三:男
取出的数据为：lisi:女
取出的数据为：张三:男
取出的数据为：lisi:女
取出的数据为：张三:男

三、使用Lock对象来保证线程的同步，则系统中不存在隐式的同步监视器对象，可以使用Lock对象的await()、signal()和signalAll()来进行控制线程间的切换；
//定义Account类 package li.test; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class Account { private final Lock lock=new ReentrantLock(); private final Condition cond=lock.newCondition(); private String accountNum; private double banlce; private boolean flag=false; Account(String accountNum,double banlce) { this.accountNum=accountNum; this.banlce=banlce; } public double getBanlce() { return this.banlce; } //使用同步代码块 /*public synchronized void draw(double drawBanlce) { if(!flag) { try { wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } else { System.out.println(Thread.currentThread().getName()+"取钱："+drawBanlce); banlce-=drawBanlce; System.out.println("账户余额为："+banlce); flag=false; notifyAll(); } } public synchronized void deposit(double depositBanlce) { if(flag) { try { wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } else { System.out.println(Thread.currentThread().getName()+"存钱："+depositBanlce); banlce+=depositBanlce; System.out.println("账户余额为："+banlce); flag=true; notifyAll(); } }*/ //使用Condition加锁 public void draw(double drawBanlce) { lock.lock(); try { if(!flag) { cond.await(); } else { System.out.println(Thread.currentThread().getName()+"取钱："+drawBanlce); banlce-=drawBanlce; System.out.println("账户余额为："+banlce); flag=false; cond.signalAll(); } } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { lock.unlock(); } } public void deposit(double depositBanlce) { lock.lock(); try { if(flag) { cond.await(); } else { System.out.println(Thread.currentThread().getName()+"取钱："+depositBanlce); banlce+=depositBanlce; System.out.println("账户余额为："+banlce); flag=true; cond.signalAll(); } } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { lock.unlock(); } } } <br/> //存钱操作 ackage li.test; public class DepoistBanlce implements Runnable { private Account account; private double depoistNum; DepoistBanlce(Account account,double depoistNum) { this.account=account; this.depoistNum=depoistNum; } @Override public void run() { // TODO Auto-generated method stub for(int i=0;i<5;i++) { account.deposit(depoistNum); } } } //取钱操作 package li.test; public class DrawBanlce implements Runnable { private Account account; private double drawNum; DrawBanlce(Account account,double drawNum) { this.account=account; this.drawNum=drawNum; } @Override public void run() { // TODO Auto-generated method stub for(int i=0;i<5;i++) { account.draw(drawNum); } } } <br/> //测试代码示例 package li.test; public class AccountTest { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Account account=new Account("ABC00001",0); DrawBanlce db=new DrawBanlce(account,500); DepoistBanlce dpb=new DepoistBanlce(account,500); Thread t1=new Thread(db,"取钱者"); Thread t2=new Thread(dpb,"存钱者甲"); Thread t3=new Thread(dpb,"存钱者乙"); t3.start(); t2.start(); t1.start(); } }

 四、Join方法:Thread提供了让一个线程等待另外一个线程的方法join（）。Join（）有三种重载的方式：1、join（）等待被重载的线程执行完成2、join（long mills）等待被join的线程最长mills毫秒3、join（long mills，int nanos）等待被join的线程最长mills毫秒+nanos微秒（千分之一毫秒）