JUC基础之Synchronized 和Lock 八锁演示

什么是JUC？

JUC

先看看如何创建普通的线程代码？通过API了解一下Callable接口和Lock锁

new Thread

实现Runnable接口 （没有返回值），效率相比于Callable相对较低，更多时候使用Callable

Callable接口

Callable

Lock接口

Lock

说一点常识

线程和进程的区别

进程：

    一个程序，比如 IDEA 是一个程序的集合 

    一个进程可以包含多个线程，至少1个

线程：

    我们打开了一个一个笔记本程序（进程） 我们可以写字，可以自动保存，可以自动同步（线程）

java默认有几个线程？

main线程，和GC垃圾回收

java真的可以开启线程吗？

答案：开不了，看源码

public synchronized void start() {
   if(threadStatus!=0)
    throw new IllegalThreadStateException();
    group.add(this);
    boolean started =false;
    try{
        start0();
        started =true;
        }finally{
          try{
            if(!started) {
              group.threadStartFailed(this);
           }
          }catch(Throwable ignore) {
       }
    }
}

private native void start0();

private native void start0(); 是 本地方法，底层的C++执行，java无法直接操作硬件

并发与并行

并发：

多线程操作同一资源（边吃饭边吃菜）

CPU一核，模拟出来多条线程，快速交替

并行：

多个人一起行走（边吃饭边看电视）

CPU多核，多个线程可以同时执行

public static void main(String[] args)
{
   //获取cpu核数
   //CPU密集型   IO密集型
   System.out.println((Runtime.getRuntime().availableProcessors()));
}

并发编程的本质，充分利用CPU的资源

线程有几个状态 ?

public enum State {
   NEW,       //新建
   RUNNABLE,     //运行
   BLOCKED,    //阻塞
   WAITING,    //等待 （死死等待）
   TIMED_WAITING,    //超时等待（有时效性的等待）
   TERMINATED;    //终止
}

还是卖票的例子

Synchronized 锁

/**
* 基本卖票的列子
* 真正公司中多线程的开发，降低耦合性     static class  Ticket  如果 实现 Runnable接口就不是oop开发 耦合性很高
* 线程就是一个单独的资源类，没有任何附属操作  （熟悉，方法）
*
*/
public class Demo01
{
    public static void main(String[] args)
    {
        //并发，多个线程操作同一个资源类,把资源类丢入线程
        Ticket ticket =new Ticket();
        //lambda  new Thread((参数)->{  代码  }).start(); 三个线程操作同一个资源，并发
        new Thread(()->{for(int i =0;i <50;i++) ticket.sale();},"Y1").start();
        new Thread(()->{for(int i =0;i <50;i++) ticket.sale();},"Y2").start();
        new Thread(()->{for(int i =0;i <50;i++) ticket.sale();},"Y3").start();
   }

   //资源类 OOP
   static class Ticket    {
       //属性 方法
       private int TicketNumber=50;
       //卖票的方式 传统的synchronized锁
       public  synchronize void sale(){
       if(TicketNumber>0){
       //卖票
       System.out.println(Thread.currentThread().getName()+"卖出了第"+TicketNumber+"张票"+",剩余"+--TicketNumber);
       }
      }
   }
 }

Lock锁

ReentrantReadWriteLock.ReadLock 读锁

ReentrantReadWriteLock.WriteLock 写锁

ReentrantLock 可重入锁

非公平锁：可以插队，不公平 （synchronized也是）
公平锁：先来后到，十分公平，一定要排队

用Lock锁完成刚才的synchronized卖票的操作


public class Demo
{
public static void main(String[] args)
    {
//并发，多个线程操作同一个资源类,把资源类丢入线程
       Ticket ticket =new Ticket();
       //lambda  new Thread((参数)->{  代码  }).start(); 三个线程操作同一个资源，并发
        new Thread(()->{for(int i =0;i <50;i++) ticket.sale();},"Y1").start();
        new Thread(()->{for(int i =0;i <50;i++) ticket.sale();},"Y2").start();
        new Thread(()->{for(int i =0;i <50;i++) ticket.sale();},"Y3").start();
   }

  //资源类 OOP
   static class Ticket    {
  //属性 方法
       private int TicketNumber=50;
       Lock lock = new ReentrantLock();
       //卖票的方式
       public synchronized void sale(){
        //加锁
       lock.lock();
            try
            {
              if(TicketNumber>0)
              {
              //卖票
              System.out.println(Thread.currentThread().getName()+"卖出了第"+TicketNumber+"张票"+",剩余"+--TicketNumber);
               }
            }
           catch(Exception e)
           {
            e.printStackTrace();
           }
           finally
           {
              //解锁
              lock.unlock();
           }
        }
    }
}

Lock锁与Synchronized锁的区别

1，Synchronized 内置的java关键字，Lock是一个java类

2，Synchronized 无法判断获取锁的状态，Lock可以判断是否获取到了锁

3，Synchronized 全自动的，会自动释放锁，Lock要手动释放锁，如果不释放锁会 死锁

4，Synchronized 线程1（获得锁，阻塞了），线程2（等待，傻傻的等待），Lock锁就不一定会等待下去 tryLock()

5，Synchronized 可重入锁，不可以被中断的非公平（无法修改，因为是关键字）

Lock是可重入锁，可以判断锁，可以设置公平锁，非公平锁

6，Synchronized 适合锁少量代码块同步问题，Lock适合锁大量的同步代码

生产者消费者问题

Synchronized版 wait notify

public class A
{
    public static void main(String[] args)
    {
            Data data = new Data();
            new Thread(()->{
            for(inti =0;i <10;i++)
            {
               try
               {
                data.increment();
               }
               catch(InterruptedException e)
               {
                e.printStackTrace();
               }
            }
          },"A").start();

        new Thread(()->{
          for(int i =0;i <10;i++)
            {
                try
               {
                data.decrement();
               }
               catch(InterruptedException e)
               {
                e.printStackTrace();
               }
            }
          },"B").start();
       }

      //等待 业务 通知
  static class Data
  {
       private int number = 0;
       //+1
       public synchronized void increment()throwsInterruptedException
       {
            if (number!=0)
                //等待
               this.wait();
               number++;
           System.out.println(Thread.currentThread().getName()+"======"+number);
           //通知其他线程 加一完毕
           this.notifyAll();
       }

          //-1
      public synchronized void decrement()throwsInterruptedException
      {
               if (number==0)
                //等待
               this.wait();
               number--;
           System.out.println(Thread.currentThread().getName()+"======"+number);
           //通知其他线程 减一完毕
           this.notifyAll();
      }
   }
}

上面的代码存在的问题：

如果线程数大于两个：if(number==0)/if(number!=0)只会判断一次，多线程的情况下，if判断会导致虚假唤醒问题，所以要使用while判断

wait后锁被释放了，线程被唤醒只是进入了一个就绪阶段不能马上运行，但在这期间其他线程可能做了操作

wait会释放锁，等他再获取锁的时候，会从释放的地方接着向下执行，所以跳过了if判断

虚假唤醒问题

Lock 版生产者和消费者问题

通过Lock可以找到Condition

Condition

Condition 精准的通知可唤醒线程


public class C
{
    public static void main(String[] args)
    {
         Data data =new Data();
          //A线程执行完去调用B B------->C------>A
         new Thread(()->{for(int i =0;i <5;i++) data.printA();},"A").start();
         new Thread(()->{for(int i =0;i <5;i++) data.printB();},"B").start();
         new Thread(()->{for(int i =0;i <5;i++) data.printC();},"C").start();

   }


//资源类
    static classData
    {
        private Lock lock = new ReentrantLock();
        private Condition conditionA = lock.newCondition();
        private Condition conditionB = lock.newCondition();
        private Condition conditionC = lock.newCondition();
        private int number=1;//标志位  1A  2B  3C
        public voidprintA()
        {
          lock.lock();
          //业务：  判断 —— 执行——通知
           try
           {
            while(number!=1)
                {
                    //等待
                   conditionA.await();
               }
               //执行
               System.out.println(Thread.currentThread().getName()+"A");
               //唤醒B number赋值
               number=2;
               conditionB.signal();
           }
           catch(Exception e)
           {
              e.printStackTrace();
           }
           finally
           {
           lock.unlock();
          }
        }

        public void printB()
        {
            lock.lock();
            try
           {
               while(number!=2)
              {
               conditionB.await();
              }
               System.out.println(Thread.currentThread().getName()+"B");
               number=3;
               conditionC.signal();
           }
           catch(Exception e)
           {
              e.printStackTrace();
           }
           finally
           {
            lock.unlock();
           }
        }

        public void printC()
        {
              lock.lock();
            try
            {
              while(number!=3)
              {
              conditionC.await();
              }
                System.out.println(Thread.currentThread().getName()+"C");
               number=1;
               conditionA.signal();
           }
           catch(Exception e)
           {
            e.printStackTrace();
           }
           finally
           {
            lock.unlock();
           }
        }
    }
}

八锁现象

那么到底什么是锁？锁的对象是什么呢？

深刻理解锁

下面代码执行是先打电话还是先发短信呢？

public static void main(String[] args)
{
Phone phone = new Phone();
    new Thread(()->{phone.sendMsg();},"sendMsg").start();
    try
    {
        TimeUnit.SECONDS.sleep(1);
    }
    catch(InterruptedException e)
    {
        e.printStackTrace();
    }
        new Thread(()->{phone.call();},"call").start();
}

//资源类
static class Phone
{
    public synchronized void sendMsg()
    {
        try
       {
          TimeUnit.SECONDS.sleep(4);
       }
       catch(InterruptedException e)
       {  
          e.printStackTrace();
       }
          System.out.println("发短信");
    }

    public synchronized void call()
    {
        System.out.println("打电话");
    }
}

永远都是先发短信 因为synchronized锁的对象是方法的调用者 由于这两个方法都是调用的phone 所以是谁先拿到锁谁先执行

是先发短信还是先hello?


//是先发短信还是先hello?

public static void main(String[] args)
{
    Phone phone = new Phone();
    new Thread(()->{phone.sendMsg();},"sendMsg").start();
    try
    {
        TimeUnit.SECONDS.sleep(1);
    }
    catch(InterruptedException e)
    {
       e.printStackTrace();
    }
      new Thread(()->{phone.hello();},"hello").start();
}

//资源类
static class Phone
{
    public synchronized void sendMsg()
    {
       try
       {
          TimeUnit.SECONDS.sleep(4);
       }
       catch(InterruptedException e)
       {
          e.printStackTrace();
       }
          System.out.println("发短信");
    }

    public synchronized void call()
    {
      System.out.println("打电话");
    }

      public voidhello()
    {
      System.out.println("hello");
    }
}

先hello，因为hello是普通方法 不是同步方法 不受锁的影响

先打电话还是先发短信呢？

public static void main(String[] args)
{
     //两个对象
     Phone phone = new Phone();
     Phone phone1 = new Phone();
     new Thread(()->{phone.sendMsg();},"sendMsg").start();
     try
     {
        TimeUnit.SECONDS.sleep(1);
     }
     catch(InterruptedException e)
     {
        e.printStackTrace();
     }
        new Thread(()->{phone1.call();},"call").start();
}

//资源类
static class Phone
{
    public synchronized void sendMsg()
    {
       try
       {
        TimeUnit.SECONDS.sleep(4);
       }
       catch(InterruptedException e)
       {
        e.printStackTrace();
       }
        System.out.println("发短信");
    }

    public synchronized void call()
    {
      System.out.println("打电话");
    }
}

先打电话，因为synchronized锁的是对象的调用者，因为是两个不同的对象，所以有两把锁，所以按着时间来执行了

先打电话还是短信呢？


public static void main(String[] args)
{
    Phone phone = new Phone();
    new Thread(()->{phone.sendMsg();},"sendMsg").start();
    try
    {
        TimeUnit.SECONDS.sleep(1);
    }
    catch(InterruptedException e)
    {
        e.printStackTrace();
    }
        new Thread(()->{phone.call();},"call").start();
}

//资源类
static class Phone
{
    public static synchronized void sendMsg()
    {
       try
       {
         TimeUnit.SECONDS.sleep(4);
       }
       catch(InterruptedException e)
       {
        e.printStackTrace();
       }
        System.out.println("发短信");
    }

    public static synchronized void call()
    {
       System.out.println("打电话");
    }
}

发短信，因为类两个方法都是static方法 锁锁住的是phone.class，两个方法公用了一把锁

现在创建两个对象，是先发短信还是先打电话呢？

public static void main(String[] args)
{
    Phone phone = new Phone();
    Phone phone1 = new Phone();
    new Thread(()->{phone.sendMsg();},"sendMsg").start();
    try
    {
        TimeUnit.SECONDS.sleep(1);
    }
    catch(InterruptedException e)
    {
        e.printStackTrace();
    }
        new Thread(()->{phone1.call();},"call").start();
 }

//资源类
static class Phone
{
    public static synchronized void sendMsg()
    {
       try
       {
        TimeUnit.SECONDS.sleep(4);
       }
       catch(InterruptedException e)
       {
        e.printStackTrace();
       }
        System.out.println("发短信");
    }

    public static synchronized void call()
    {
        System.out.println("打电话");
    }
}

发短信，两个对象的类模版只有一个，所以只要加了static的方法，锁的就是class

先发短信还是打电话呢？

public static void main(String[] args)
{
    Phone phone = new Phone();
    new Thread(()->{phone.sendMsg();},"sendMsg").start();
    try
    {
        TimeUnit.SECONDS.sleep(1);
    }
    catch(InterruptedException e)
    {
       e.printStackTrace();
    }
      new Thread(()->{phone.call();},"call").start();
}

//资源类
static class Phone
{
    //静态的同步方法 
    public static synchronized void sendMsg()
    {
       try
       {
          TimeUnit.SECONDS.sleep(4);
       }
       catch(InterruptedException e)
       {
        e.printStackTrace();
       }
        System.out.println("发短信");
   }

   //普通的同步方法
   public  synchronized void call()
   {
        System.out.println("打电话");
   }
}

打电话，因为static方法锁的是class模版，普通同步方法锁的是调用者，两个方法两把锁

和上面一样，两个对象用了两把锁，是先打电话，两个方法两把锁按时间执行


public static void main(String[] args)
{
    Phone phone = new Phone();
    Phone phone1 = new Phone();
    new Thread(()->{phone.sendMsg();},"sendMsg").start();
    try
    {
        TimeUnit.SECONDS.sleep(1);
    }
    catch(InterruptedException e)
    {
        e.printStackTrace();
    }
        new Thread(()->{phone1.call();},"call").start();
}

//资源类
static class Phone
{
    //静态的同步方法 锁的class模版
    public static synchronized void sendMsg()
    {
       try
       {
          TimeUnit.SECONDS.sleep(4);
       }
       catch(InterruptedException e)
       {
          e.printStackTrace();
       }
          System.out.println("发短信");
   }

    //普通的同步方法 锁的调用对象
    public  synchronized void call()
    {
        System.out.println("打电话");
    }
}

总结：

synchronized锁的是对象的调用者

new this 是具体的的一个手机对象

static Class 是Phone.class调用 是唯一的一个模版

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,657评论 6赞 492
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,662评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 158,143评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,732评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,837评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,036评论 1赞 291
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,126评论 3赞 410
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,868评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,315评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,641评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,773评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,470评论 4赞 333
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,126评论 3赞 317
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,859评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,095评论 1赞 267
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,584评论 2赞 362
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,676评论 2赞 351