学习笔记：java多线程 JUC之三
精确通知顺序访问
import java.util.Locale;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 多线程之间按顺序调用，实现A->B->C
* 三个线程启动，要求如下：
*
* AA打印5次，BB打印10次，CC打印15次
* 接着
* AA打印5次，BB打印10次，CC打印15ci
*
* 。。。来10轮
*
* 1 高内聚低耦合前提下，线程操作资源类
* 2 判断/干活/通知
* 3 多线程交互中，必须防止多线程的虚假唤醒，也即（判断只用while，不能用if）
* 4 注意标志位
*/
class ShareResource
{
private int number=1;//1.A 2.B 3.C
private Lock lock =new ReentrantLock();
private Condition condition1=lock.newCondition();
private Condition condition2=lock.newCondition();
private Condition condition3=lock.newCondition();
public void printA(){
lock.lock();
try{
while (number!=1)
{
condition1.await();
}
for (int i=0;i<5;i++){
System.out.println("AA"+(i+1));
}
number=2;
condition2.signal();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void printB(){
lock.lock();
try{
while (number!=2)
{
condition2.await();
}
for (int i=0;i<10;i++){
System.out.println("BB"+(i+1));
}
number=3;
condition3.signal();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void printC(){
lock.lock();
try{
while (number!=3)
{
condition3.await();
}
for (int i=0;i<15;i++){
System.out.println("CC"+(i+1));
}
number=1;
condition1.signal();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
public class ThreadOrderAccess {
public static void main(String[] args) {
ShareResource shareResource = new ShareResource();
new Thread(()->{
for (int i=0;i<10;i++){
shareResource.printA();
}
},"A").start();
new Thread(()->{
for (int i=0;i<10;i++){
shareResource.printB();
}
},"B").start();
new Thread(()->{
for (int i=0;i<10;i++){
shareResource.printC();
}
},"C").start();
}
}8锁的现象
import java.util.concurrent.TimeUnit;
class Phone
{
public synchronized void sendEmail() throws Exception
{
//Thread.sleep(4000);
try {
TimeUnit.SECONDS.sleep(4);
}catch (InterruptedException e){e.printStackTrace();}
System.out.println("-----sendEmail");
}
public synchronized void sendSMS() throws Exception
{
System.out.println("-----sendSMS");
}
public void hello()
{
System.out.println("-----hello");
}
}
public class Lock8 {
public static void main(String[] args) {
Phone phone = new Phone();
Phone phone1=new Phone();
new Thread(()->{
try {
phone.sendEmail();
}catch (Exception e){
e.printStackTrace();
}
},"A").start();
new Thread(()->{
try {
phone.sendSMS();
}catch (Exception e){
e.printStackTrace();
}
},"B").start();
}
}
/**
* 题目：多线程8锁
* 1 标准访问，请问先打印邮件还是短信？ 邮件
* 2 邮件方法暂停4秒，请问先打印邮件还是hello？ 邮件
* 3 新增一个普通hello()，请问先打印邮件还是hello? hello
* 4 两部手机，请问先打印邮件还是短信？ 短信
* 5 两个静态同步方法，同一部手机，请问先打印邮件还是短信？ 邮件
* 6 两个静态同步方法， 2 部手机，请问先打印邮件还是短信？ 邮件
* 7 一个普通同步方法 一个静态同步方法 一部手机 请问先打印邮件还是短信？ 短信
* 8 一个普通同步方法 一个静态同步方法 两部手机 请问先打印邮件还是短信？ 短信
*
* 笔记
* 一个对象里面如果有个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法其他的
* 线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法
* 锁的是当前对象this，被锁定后，其他的线程都不能进入到当前对象的其他的synchronized方法
*
* 加个普通方法后发现和同步锁无关
* 换成两个对象后，不是同一把锁了，情况立刻变化。
*
* 都换成静态同步方法后，情况有变化
* 所有的非静态同步方法用的都是同一把锁——实例对象本身
*
* synchronized实现同步的基础：Java中的每一个对象都可以作为锁。
* 具体表现为以下3种形式。
* 对于普通同步方法，锁的是当前实例对象。
* 对于静态同步方法，锁是当前类的class对象
* 对于同步方法块，所示synchronized括号里配置的对象
*
* 当一个线程试图访问同步代码块时，它首先必须得到锁，推出或抛出异常时必须释放锁。
*
* 也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取值，
* 可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，
* 所以毋须等待该实例对象以获取锁的非静态同步方法释放锁就可以获取他们自己的锁。
*
* 所有的静态同步方法用的也是同一把锁——类对象本身
* 这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有静态条件的。
* 但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，
* 而不管是同一个实例对象的静态同步方法之间，
* 还是不同的实例对象的静态同步方法之间，之要它们同一个类的实例对象！
*/synchronized 锁的不是方法 而是整个对象（this）！