java基础系列23

/code>

br> 对象名.join()

br>　　调用此方法，当前线程会 让出cpu的使用权，优先执行其他线程，该线程也可能会处于被执行的对象。yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会更大而已。

　　sleep方法有两个重载版本：

并行和并发的区别

线程安全：线程主体中的某段代码同时只有一个线程可以访问，其他线程处于等待状态

解决问题：为了解决多线程下访问资源共享时产生数据安全问题。

如：卖票案例 出现了线程安全 重复的票不能出现

步骤：

成员位置建立锁对象；

synchronized(锁对象){

出现安全问题代码

}

  1、锁对象 任意对象

  2、 必须保证多个线程使用的是同一个锁对象

  3、把{} 只让一个线程进

例子：

public class RunnableImpl implements Runnable{ // 定义共享资源 线程不安全 private int ticket = 100; //在成员位置创建一个锁对象  Object obj = new Object(); // 线程任务 卖票 @Override public void run() { while(true){ //建立锁对象  synchronized (obj){ if(ticket>0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } //卖票操作 System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票"); ticket--; } } } } } 

步骤

1 、创建一个方法 修饰符添加synchronized

2、 把访问了 共享数据的代码放入到方法中

3 、调用同步方法

public class RunnableImpl implements Runnable{ // 定义共享资源 线程不安全 private int ticket = 100; // 线程任务 卖票 @Override public void run() { while(true){ payTicket();//调用下面synchronized修饰的方法 } }  public synchronized void payTicket(){ if(ticket>0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } //卖票操作 System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票"); ticket--; } } } 

java.util.concurrent.locks.Lock;机制提供了比synchronized代码块和synchronized方法更广泛的锁操作，在类中定义一个锁对象： ReentrantLock lock = new ReentrantLock();

在实际业务代码中 先上锁 lock.lock() 执行完业务后 释放锁 lock.unlock()。

Lock lock = new ReentrantLock(true); //加锁 lock.lock(); try{ //业务逻辑 }finally{ //放锁 lock.unlock(); }

1、用法：synchronized （隐式锁）在需要同步的对象中加入此控制，synchronized可以加在方法和代码块上面，括号中表示要锁的对象。

lock(显示锁) 需要显示在指定的 起始和终止位置 。 一般使用 ReentrantLock 类作为锁。 加锁 lock(),解锁 unlock() . finally块一定要解锁，不然会造成死锁情况。

2、性能： synchronized 是Java的关键字，在

实现了对资源的同步互斥访问 . 而 lock 是一个接口。里面有许多方法。

比如：尝试获取锁包括立即返回是否成功的tryLock(),以及一直尝试获取的lock()方法和尝试等待指定时间长度获取的方法，比synchronized相对灵活了许多。

3、机制：synchronized（悲观锁CUP，怕别人抢吃的）,　同一时刻不管是读还是写都只能有一个线程对共享资源操作，其他线程只能等待. 当锁的对象成功完成或者抛出异常时，会自动释放锁。

lock(乐观锁CAS)

，具体下面会说道，大致就是可以尝试获得锁，线程可以不用一直等待。

lock()：获取锁，如果锁被暂用则一直等待 unlock():释放锁 tryLock(): 注意返回类型是boolean，如果获取锁的时候锁被占用就返回false，否则返回true tryLock(long time, TimeUnit unit)：比起tryLock()就是给了一个时间期限，保证等待参数时间 lockInterruptibly()：用该锁的获得方式，如果线程在获取锁的阶段进入了等待，那么可以中断此线程，先去做别的事　　 

补充重点精华：ReentrentLock 和ReentrentReadWriteLock两个类可重入的锁，即当同一线程获取到锁之后，他在不释放锁的情况下，可以再次获取到当前已经拿到的锁，只需标记获取到锁的次数加一即可；

ReentrantReadWriteLock是Lock的另一种实现方式，我们已经知道了ReentrantLock是一个排他锁，同一时间只允许一个线程访问，而ReentrantReadWriteLock允许多个读线程同时访问，但不允许写线程和读线程、写线程和写线程同时访问。

通过在读多，写少的高并发情况下，我们用

分别获取读锁和写锁来提高系统的性能，因为读锁是共享锁，即可以同时有多个线程读取共享资源，而写锁则保证了对共享资源的修改只能是单线程的。

线程的生命周期

新建

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

就绪

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

运行

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

阻塞

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

死亡

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

线程中的等待和通知机制

进入休眠状态 并 释放锁

。

当前线程不会马上释放该对象锁

，要等到程序退出同步块后，当前线程才会释放锁。

只能在同步方法或同步块中调用。

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

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

Condition中的signalAll()相当于Object的notifyAll()方法。

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

15、

 * 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(); } }  } }  

 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(); } } }   //生产者 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();//表示让生产者生产 }  } }  

 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 来解决存钱和取钱案例

在 Java 5.0 提供了 java.util.concurrent(简称JUC)包,在此包中增加了在并发编程中很常用的工具类,用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文中的 Collection 实现等。

 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(); } }  

 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 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(); } }