黑马程序员_<<线程,Runnable,锁>>

最新推荐文章于 2023-06-19 11:31:15 发布
最新推荐文章于 2023-06-19 11:31:15 发布
阅读量1.2k 收藏
点赞数
分类专栏： 为黑马而努力 文章标签： 线程 多线程 安全 黑马程序员 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011976033/article/details/11640235
版权

--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------


 1.实现Runnable接口

       1.步骤

            1.创建类(A)实现接口Runnable，复写run()方法

      2.创建Thread对象，然后把类A的对象作为参数传给Thread的构造函数，这是把其关联起来。

      3.通过创建的线程对象，然后开启线程。

                解答：复写run()方法，里面存的是线程要运行的代码

       因为Runnble接口中只有一个run()方法，所以没有办法启动线程，所以还得使用Thread类来启动线程，所以要把Runnable的子类的对象作为参数传给Thread类构造函数。

       2.售票例子(Runnable接口)

    

 public class Tick implements Runnable {
  private int tick = 10;
 
  public void run(){
    while (tick > 0) {
      System.out.println(Thread.currentThread().getName() + "卖了第"
           + (tick--) + "张票");
    }
  }
}

结果：
Thread-0卖了第10张票
Thread-1卖了第10张票
Thread-0卖了第9张票
Thread-1卖了第8张票
Thread-0卖了第7张票
Thread-1卖了第6张票
Thread-0卖了第5张票
Thread-0卖了第4张票
Thread-0卖了第3张票
Thread-0卖了第2张票
Thread-0卖了第1张票
Thread-1卖了第0张票

 

   从结果上可以看出，这是我们想要的那种结果，多个窗口共同买共有的票。

3.Runnable接口和Thread类的区别与联系

               1.Runnable接口可以避免单继承的限制，要是继承Thread类的话，那么就不能继承其他的类了，因为只能单继承，如果实现了接口Runnale后，还可以继承其他的类，或是是实现其他的接口

     2.Runnable实现了资源的共享，例如(售票程序的票)

     3.Runnable实增强了程序的健壮性，代码能够被多个程序共享，实现了数据 与代码是独立的。

     4.实现Runnable接口的线程的运行代码存在实现Runnable接口子类的run()方法中，继承Thread类的线程的代码存在Thread子类的run()方法中。

  所以在以后的开发中，使用Runnble接口比较好，更多。

 2.线程的安全问题

     1.原因

          当多条语句执行多个线程共享的资源，执行到一部分后，执行权被抢夺了，导致共享资源的不正正常修改，所以就产生了线程的安全问题。

        例如：售票小例子


public class Ticket implements Runnable {
  private int tick = 10;
 
  public void run() {
    while (true) {
      try {
         if (tick > 0) {
           Thread.sleep(10);
           System.out.println(Thread.currentThread().getName()+ "卖了第"
               + (tick) + "张票");
           tick--;
         }
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
 
    }
  }
}
public class Text {
  public static void main(String[] agrs) {
    Ticket tt=new Ticket();
    new Thread(tt).start();
    new Thread(tt).start();
  }
}
结果：
Thread-1卖了第10张票
Thread-0卖了第10张票
Thread-1卖了第8张票
Thread-0卖了第8张票
Thread-0卖了第6张票
Thread-1卖了第5张票
Thread-1卖了第4张票
Thread-0卖了第3张票
Thread-0卖了第2张票
Thread-1卖了第2张票
Thread-0卖了第0张票




  结果出现了：产生了重复的票，并且出现了0票，那么这是不正常的现象的。

     2.同步代码块---解决办法

             1.概述

         利用的是关键子(synchronized)来处理线程同步问题，保证线程安全，锁就好比门上的锁一下，执行的顺序是：首先是判断锁是否是开着的，若是开着的，那么就可以进去(执行同步代码)然后把锁锁上，执行完后，把锁释放(把锁开开)，判断锁是锁着的，那么就在外面等着，直到里面的人把锁开开，出来。(这样保证的是同步代码在某一段时间只有一个线程在执行。)


   

             2.格式

         synchronized(对象){执行共享资源的代码}

             3.同步规则

                      必须是多个线程执行(至少两个)才可以产生同步，必须是多个线程使用的是同一个锁，

           优点：解决了多线程的安全问题

           弊端：多线程需要判断，那么就会消耗时间，消耗资源


public class Ticket implements Runnable {
  private int tick = 10;
 
  public void run() {
    while (true) {
      synchronized (this) {
         try {
           if (tick > 0) {
             Thread.sleep(10);
             System.out.println(Thread.currentThread().getName()
                 + "卖了第" + (tick) + "张票");
             tick--;
           }
         } catch (InterruptedException e) {
           e.printStackTrace();
         }
      }
 
    }
  }
}
结果：
Thread-0卖了第10张票
Thread-0卖了第9张票
Thread-0卖了第8张票
Thread-1卖了第7张票
Thread-1卖了第6张票
Thread-1卖了第5张票
Thread-1卖了第4张票
Thread-1卖了第3张票
Thread-1卖了第2张票
Thread-1卖了第1张票


这样结果就和我们正常想要的是一样的，没有异常现象

     3.同步方法---解决办法

         1.概述

               因为方法和代码块都是用来封装代码的，那么代码块可以使用锁来解决同步问题，那么函数也可以使用锁，使方法也可以操作同步问题。

       2.格式

                   public synchronized 方法返回类型 方法名(参数){方法体}

     3.使用

                怎眼确定锁的位置，寿面判断那些是线程运行的代码，那些是共享资源，那些同步代码是执行的是同步资源，那么就把那些操作同步资源的语句使用锁来进行括起来。

 

   例如：客户向银行存钱，每次存三次，每次存100，分两个地方存户存

    思路：共享资源：总价钱，银行，有两个线程(模拟两个地方存)

 

         

**
 * 银行类
 */
public class Bank {
  private int sum;// 表示的是当前账户的总额
 
  public synchronized void add(int mon) {// 存方法，加锁的话，那么里面的语句在一段时间内必须是一个线程在执行
    sum += mon;
    try {
      Thread.sleep(10);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("sum=" + sum);
  }
}
public class Cus implements Runnable {
    private Bank bank=new Bank();
    public void run(){//线程执行的代码(线程)
     for(int i=0;i<3;i++){
       bank.add(100);
    }
    }
}
public class Text {
  public static void main(String[] agrs) {
    Cus tt=new Cus();//客户
    new Thread(tt).start();//开始存
    new Thread(tt).start();//开始存
   
  }
}
结果：
sum=100
sum=200
sum=300
sum=400
sum=500
sum=600


     4.同步代码块和同步函数的选择

          假如连续的代码是同步代码，并且都是执行的都是共享资源，那么就可以把其抽取成函数，并且定义为同步函数

       假如一个函数中是全是同步代码，并且执行的全是共享资源，那么就把其定义为同步函数

     5.扩展

            回顾：一共分为四种代码块

    普通代码块：就是定义在方法中的代码块。

     构造块：定义在类中的代码块，优先于构造方法，重复调用。     

    静态块：使用static关键字声明的，只执行一次，优先于构造块。

    同步代码块：使用synchronized关键字声明的代码块，称为同步代码块。格式：synchronized(同步对象){}

 

 4.锁对象的确定

     1.同步函数的锁是this

             验证思路：还是使用的卖票程序，使用两个线程，他们执行的代码不同，一个是同步代码块(锁的对象是this  synchronized(this){}),另一个线程执行的同步函数，如果结果没有异常，那么他们就完全符合线程同步的规则，

         多个线程执行的是同步代码，并且他们的是锁是同一个锁，因为同步代码块的锁对象是this，那么此时同步函数锁的对象也是this

      

               

 /*售票机*/
public class Ticket implements Runnable {
  private int tick = 100;
  public boolean flag = true;
 
  public void run() {
    if (flag) {
      while (true) {
         synchronized (this) {
           try {
             if (tick > 0) {
               Thread.sleep(10);
               System.out.println(Thread.currentThread().getName()
                   + "卖了第" + (tick--) + "张票");
             }
           } catch (InterruptedException e) {
             e.printStackTrace();
           }
         }
      }
 
    } else
      while (true)
         show();
  }
 
  public synchronized void show() {// 同步函数
    try {
      if (tick > 0) {
         Thread.sleep(10);
        System.out.println(Thread.currentThread().getName()+ "卖了第"
             + (tick) + "张票");
         tick--;
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}
public class Text {
  public static void main(String[] agrs) {
    Ticket tt=new Ticket();
    new Thread(tt).start();
    /*这里是主线程睡眠一下，让线程1先运行，防止直接改变标志位*/
    try {
      Thread.sleep(50);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    tt.flag=false;//更改标志位
    new Thread(tt).start();//开始存
   
  }
}
 
部分结果：
   Thread-0卖了第100张票
Thread-0卖了第99张票
Thread-0卖了第98张票
Thread-0卖了第97张票
Thread-0卖了第96张票
Thread-0卖了第95张票
Thread-1卖了第94张票
Thread-1卖了第93张票
Thread-1卖了第92张票

 

     从结果上额可以看出，结果是正常的，所以结论是正确的，同步函数的锁对象是this

     2.静态同步函数锁对象

         静态同步函数的锁是：该方法所在类的字节码文件对象：类名.class

     验证方法：和上面的一样，把同步代码块的锁对象改为：Ticket.class

 

       

/*售票机*/
public class Ticket implements Runnable {
  private static int tick = 100;
  public boolean flag = true;
 
  public void run() {
    if (flag) {
      while (true) {
         synchronized (Ticket.class) {
           try {
             if (tick > 0) {
               Thread.sleep(10);
               System.out.println(Thread.currentThread().getName()
                   + "卖了第" + (tick--) + "张票");
             }
           } catch (InterruptedException e) {
             e.printStackTrace();
           }
         }
      }
 
    } else
      while (true)
         show();
  }
 
  public static synchronized void show() {// 同步函数
    try {
      if (tick > 0) {
         Thread.sleep(10);
        System.out.println(Thread.currentThread().getName()+ "卖了第"
             + (tick) + "张票");
         tick--;
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

     结果：和上面的一样，正常

 

     我们可以这样思考，静态方法是随着类的加载而加载，此时没有类的对象，但是还是要找个对象，那么就是类的字节码文件的对象。

3.死锁

      1.死锁产生的原因

          死锁产生的原因是：一个所中还有另外一个锁，但是这两个锁对象是不相同的，其中一个锁(A)需要另外一个锁(B)，而锁(B)也需要锁(A),这样有时候她们都不会妥协，那么就会产生死锁。

      2.举例死锁

       

class MyLock {
  static Object lockA = new Object();
  static Object lockB = new Object();
}
 
public class DeadLock implements Runnable {
  public boolean flag = true;
 
  public DeadLock(boolean f) {
    this.flag = f;
  }
 
  public void run() {
    if (flag) {
      // while (true) {
      synchronized (MyLock.lockA) {
         System.out.println("ifLockA");
         synchronized (MyLock.lockB) {
           System.out.println("ifLockB");
         }
         // }
      }
    } else {
      // while (true) {
      synchronized (MyLock.lockB) {
         System.out.println("elseLockB");
         synchronized (MyLock.lockA) {
           System.out.println("elseLockA");
         }
         // }
      }
    }
  }
}
public class Text {
  public static void main(String[] agrs) {
    DeadLock l1 = new DeadLock(true);// 第一个线程
    DeadLock l2 = new DeadLock(false);// 第二个线程
    new Thread(l1).start();// 开启线程
    new Thread(l2).start();// 开启线程
  }
}
 
结果：可能会死锁
  例如：
if LockA
else LockB

这就产生了死锁

 

1. 资源共享的时候需要进行同步操作

2. 程序中过多了同步操作会产生死锁

死锁就是程序中互相的等待。

 

--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------


奋斗的路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java Runnable接口创建线程
08-30
Java Runnable接口创建线程 Java中的线程创建方式有多种，其中使用Runnable接口创建线程是一种最常用的方式。本文将详细介绍Java Runnable接口创建线程的相关知识点。 什么是Runnable接口 Runnable接口是Java语言...
（53）多线程 - 线程安全-锁机制-同步块+Runnable接口
Ricardo__Lu的博客
08-01 331
/** * <线程同步:锁机制(synchronized)、队列 <并发控制 <线程不安全：数据有负数、或有相同等情况 * <什么是并发：就是同一个对象多个线程同时操作（导致线程不安全） * <锁机制(synchronized)：1.同时操作同一个数据的时候，对其中一条线程开放，并锁上，该线程操作完毕后锁释放，再轮到其他线程 2.执行效率比较差 * <同...
java中Runnable多线程用lock实现锁
最新发布
gb4215287的博客
06-19 374
java中Runnable多线程用lock实现锁
Java多线程
Rul丶的博客
07-07 115
JavaSE 多线程 Java命令运行一个Java程序的过程 Java命令首先启动了一个JVM进程，该JVM进程先会创建一个main线程，在main线程中，运行朱磊中的main方法。 JVM是多线程的，因为一直存在着一个垃圾回收器线程。 多线程的实现方法一： Thread： 创建一个继承Thread类的子类。 重写子类的run方法 创建一个Thread的子类对象 对象.start()启动线程 public class Demo1Name { public static void main(String
作者：unascribed你知道什么意思么？
san_dunfan的专栏
03-13 1万+
今天看Thread，突然看见一个很有意思的东西。也许大家早就发现了。 看到了没？在Thread类中，作者的名字是unascribed。然后就去百度和翻译了一下，解释是这个单词的意思是：无归属的。 也就是这个类不知道作者是谁。 真是有意思。
JDK源码中的 @author unascribed 注释闲谈
afabama的博客
04-10 3442
在看源码的时候，突然发现了个有意思的现象@author unascribed，那么这个注释是个什么意思呢 unascribed 译为未归类的 其实就是跟中文里的大神 “佚名” 一样 ...
Java向Runnable线程传递参数方法实例解析
08-19
Java向Runnable线程传递参数方法实例解析 Java是一种支持多线程编程的语言，线程是Java程序中最基本的执行单元。在线程编程中，线程之间的数据传递是一种非常常见的需求。在Java中，Runnable接口是实现多线程的关键...
java多线程编程之使用runnable接口创建线程
09-04
在Java多线程编程中，使用`Runnable`接口创建线程是一种常见的方法，因为它具有一定的灵活性和可重用性。这种方式允许我们不直接继承`Thread`类，避免了Java单继承的限制。以下是关于`Runnable`接口创建线程的详细...
Java多线程实现Runnable方式
08-27
主要为大家详细介绍了Java多线程如何实现Runnable方式，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java 多线程Thread与runnable的区别
08-29
Java 多线程 Thread 与 Runnable 的区别 Java 多线程技术是 Java 语言中的一种基础技术，用于实现多任务并发执行的功能。在 Java 中，实现多线程有两种方法：继承 Thread 类和实现 Runnable 接口。在本文中，我们将...
Java线程基础(5): 线程状态之 Runnable
mingyuli的博客
12-06 3668
在上一篇我们粗略谈到了 Java 的6种线程状态，并对其中较为简单的 NEW 和 TERMINATED 做了分析，现在我们具体来看下 State.RUNNABLE状态，即所谓的可运行状态。（以下简称 runnable） 再次强调，这里谈论的是Java虚拟机层面所暴露给我们的状态，与操作系统底层的线程状态是两个不同层面的事。 具体而言，这里说的 Java 线程状态均来自于 Thread 类下的 State 这一内部枚举类中所定义的状态： 什么是 RUNNABLE？ 直接看它的 Javadoc.
Java从入门到放弃26---线程的三种创建方式之实现Runnable接口
DOGIOOH的博客
06-03 2861
Java从入门到放弃26—线程的三种创建方式之实现Runnable接口 01 Runnable接口 Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。Runnable 为非 Thread 子类的类提供了一种激活方式。通过实例化某个 Thread 实例并将自身作为运行目标，就可以运行实现 Runnable 的类而无需创建 Thread ...
Java 线程状态之 RUNNABLE
Just do IT
03-21 3627
深入探讨了 Java 线程的 RUNNABLE 状态, 特别是对处在 IO 阻塞时的状态进行了深入分析.
面试官问：为什么 Java 线程没有Running状态？我懵了
勇往直前的专栏
08-13 980
Java虚拟机层面所暴露给我们的状态，与操作系统底层的线程状态是两个不同层面的事。具体而言，这里说的 Java 线程状态均来自于 Thread 类下的 State 这一内部枚举类中所定义的状态： 什么是 RUNNABLE？ 直接看它的 Javadoc 中的说明： “ 一个在 JVM 中执行的线程处于这一状态中。（A threadexecutingin the Java virtual machine is in this state.） 而传统的进（线）程状态一般划分如下： “ 注...
在JAVA源码中作者:unascribed的趣事
张波的博客
09-05 366
在JAVA源码中作者:unascribed的趣事 unascribed 今天再看JAVA远啊的时候 发现了源码的最基本类是这个 这里有个作者 后来查了一下 发现这个作者的意思是 不属于任何人 感觉也是SUN公司的一个彩蛋吧 不输入任何一个人 但是有属于任何一个人 啊哈哈哈哈 ...
线程执行任务给run方法加锁结果演示以及解决并发死循环问题的内容总结
weixin_69252724的博客
02-05 476
给线程任务run方法加锁导致结果,以及线程通信死循环问题解决
使用Runnable接口创建线程，很简单
weixin_47556601的博客
02-19 7415
大家好，今天分享.使用Runnable接口创建线程 首先Java创建线程可以通过三种方法： 即： 1.继承Thread类创建线程类（重点） 2.通过Runnable接口创建线程类（重点） 3.通过Callable接口（了解即可） 今天，使用Runnable接口创建线程。 步骤： 1.定义MyRunnable类实现.Runnable接口 2.创建run()方法，编写线程执行体 3.创建线程对象，调用start（）方法启动线程 package Demo01; public class Thread03
【Java】线程基本使用——实现 Runnable接口
热门推荐
兮动人
04-07 2万+
实现 Runnable 接口 说明 java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然不可能了。 java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程 应用案例 请编写程序，该程序可以每隔1秒。在控制台输出“hi！”，当输出10次后，自动退出。 请使用实现Runnable接口的方式实现。这里底层使用了设计模式【代理模式】=> 代码模拟实现Runnable接口 开发线程的机制。 ...
Java基础-Runnable启动线程的使用
二丫的博客
09-26 3641
Runnable启动线程的使用 实现线程的第二种方式： Runnable接口 Runnable 接口的实现类的线程 通过Thread类启动 需要把实现类对象传入Thread类的构造方法中 然后通过Thread的start方法启动该Runnable实现类的线程。 Runnable实现类线程 只需要创建一个对象 然后传入多个Thread类构造方法中，通过多个Thread对象去启动多个线程。 Runnable接口的优点： 可以避免由于Java单继承带来的局限性（不占继承名额） 适合多个相同程序的代码去处
LinkedBlockingqueue<Runnable>
06-13
`LinkedBlockingQueue<Runnable>` 是 Java 中一个实现了 `BlockingQueue` 接口的阻塞队列，它可以用于实现生产者-消费者模型，其中生产者将任务加入队列，消费者从队列中取出任务并执行。 `LinkedBlockingQueue<Runnable>` 的底层实现是一个链表，它具有以下特点： 1. 队列容量没有限制，可以一直添加元素，不会出现队列溢出的情况。 2. 队列支持两种操作：插入元素和取出元素。如果队列为空，取出元素的操作会被阻塞，直到队列中有新的元素；如果队列已满，插入元素的操作会被阻塞，直到队列中有空闲的位置。 3. 队列中的元素会按照先进先出（FIFO）的顺序进行处理。 `LinkedBlockingQueue<Runnable>` 通常用于线程池中的任务队列，它可以自动平衡生产者和消费者之间的速度差异，从而提高了系统的吞吐量和响应速度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值