java黑洞网 首页 博客 问答 站长公众号 pdf 视频 游戏 脚本 实战 其它资源
写博客 注册
本站消息

站长简介/公众号

  出租广告位,需要合作请联系站长


+关注
已关注

分类  

暂无分类

标签  

暂无标签

日期归档  

2024-11(2)

对于多线程的学习总结

发布于2021-03-13 14:48     阅读(763)     评论(0)     点赞(6)     收藏(1)

最近刚学完多线程，趁着自己还没忘记，现总结总结，大家凑合着看看吧

1.多线程的实现方法

1.1并行与并发
    并行：多个对象同一时刻执行多个任务
    并发：单个对象在同一时间段交替执行多个任务
1.2进程和线程
    进程：指正在运行的一个程序（cpu分配资源的基本单位）
    线程：正在运行的程序中的一个执行任务（执行单元）（进程中分配资源的基本单位）
1.3多线程的三种实现方法
    1.3.1继承Thread类
        一个类通过继承Thread类，重写父类的run()方法，来实现多线程，通过这种方法来实现多线程，直接创建对象调用start()方法来开始线程;
        start()方法实际上是开辟新的栈内存，在新的栈内存中执行线程任务
         所以要想开始新的线程，必须调用start()方法
    1.3.2实现Runnable接口
         一个类可以通过实现Runnable接口来实现多线程，重写接口中的run方法，然后将实现了接口的类的对象作为参数传递给Thread对象，再通过调用start()方法来开启线程：new Thread(Runnable对象)
    1.3.3实现Callable接口
         一个类可以通过实现Callable接口来实现多线程，重写接口的call方法，然后创建类的对象作为参数传递给FutureTask对象，然后将FutureTask对象作为参数传递给Thread对象：
           

  1.  FutureTask ft = new FutrueTask(Call对象);
  2.            Thread t = new Thread(ft);
  3.            t.start();


        call方法是有一个返回值的，Callable是一个泛型接口，泛型的类型必须和call方法的返回值类型相同
            在线程运行结束后，可以通过FutureTask对象调用get方法来获取返回值
    1.3.4三种方式的比较
            继承Thread相比较起来编写代码少，但是该类无法去继承其他类，降低了可扩展性
            其他两种实现接口的方式提高了可扩展性，在实现多线程时还可以去继承其他类(以后用实现接口较多)

2.多线程的成员方法

3.1设置获取名字
   

  1. String getName();//获取线程的名字
  2.     Thread(String name);//通过构造方法给线程定义一个名字
  3.     setName(String name);//设置线程的名字


3.2获取当前线程对象
   

 public static Thread currentThread();//获取当前调用方法的线程对象


3.3睡眠方法
   

 public static void sleep(long time);//设置当前线程休眠time时间


3.4线程的优先级
    声明：线程的优先级的高低只是说明其抢占CPU时间片的概率的大小，并不能保证在CPU空闲时一定能抢到执行权

  1.  
  2.     int getPriority();//获取当前线程的优先级
  3.     void setPriority(int priority)//给线程设置优先级
  4.     注：优先级默认为5，范围为MIN_PRIORITY(1)-MAX_PRIORITY(10)


3.5守护线程
   

void setDaemon(boolean false);//设置一个线程为守护线程


    守护线程时为了给其他线程做辅助工作，当普通线程结束时不管守护线程是否结束，它都会随之结束

3.多线程的安全问题

3.1产生安全问题原因
      当多个线程共享资源时，并且多个线程都对资源数据进行增删改操作时，会出现安全问题。

3.2解决方法
    3.2.1同步代码块
        同步代码块的格式：
        

synchronized(锁对象){//多线程对共享资源操作的代码 }


        注意：①锁对象可以是任意对象
              ②多线程必须用同一把锁
        同步代码块解决多线程安全问题的原理：使一个线程在对共享数据进行操作时，其他线程无法对其进行操作
    3.2.2同步方法
         同步方法的格式：
         

public [static] synchronized 返回值类型 方法名(){}


        static同步方法 锁对象是 this
         非static同步方法 锁对象是 类名.class
    3.2.3创建锁对象
         可以自己实例化一个锁对象：Lock lock = new ReenTrantLock
         在需要加锁的代码位置lock();需要解开锁的位置unlock();

相关代码：

这里是同步代码块写了一个经典的卖票的线程安全问题，同步方法不做演示

  1.  
  2. public class MySynchronizedTest1 {
  3.     public static void main(String[] args) {
  4.         Ticket ticket = new Ticket();
  5.         Thread t1 = new Thread(ticket);
  6.         Thread t2 = new Thread(ticket);
  7.         Thread t3 = new Thread(ticket);
  8.  
  9.         t1.setName("窗口1");
  10.         t2.setName("窗口2");
  11.         t3.setName("窗口3");
  12.  
  13.         t1.start();
  14.         t2.start();
  15.         t3.start();
  16.     }
  17. }
  18. class Ticket implements Runnable{
  19.     //定义票的数量
  20.     private int ticket = 100;
  21.     private static Object obj = new Object();
  22.     @Override
  23.     public void run() {
  24.         while(true){
  25.             //设置同步代码块，将操作共享数据的代码放到synchronized(Object obj){}的大括号中
  26.             synchronized (obj){
  27.                 //就是当前的线程对象.
  28.                 if(ticket <= 0){
  29.                     break;//说明票已经卖完了
  30.                 }else{
  31.                     //卖每一张票需要时间，所以这里让它睡眠一下再继续卖下一张
  32.                     try {
  33.                         Thread.sleep(150);
  34.                     } catch (InterruptedException e) {
  35.                         e.printStackTrace();
  36.                     }
  37.                     ticket--;
  38.                     System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
  39.                 }
  40.             }
  41.         }
  42.     }
  43. }

3.3死锁问题
    死锁：由于锁的嵌套导致线程A等待线程B的锁，线程B等待线程A的锁，所以导致程序无法正常执行

代码演示：

  1. //死锁
  2. public class MySynchronizedTest3 {
  3.     public static void main(String[] args) {
  4.         Object objA = new Object();
  5.         Object objB = new Object();
  6.  
  7.         new Thread(()->{
  8.             while(true){
  9.                 synchronized (objA){
  10.                     synchronized (objB){
  11.                         System.out.println("我在走路");
  12.                     }
  13.                 }
  14.             }
  15.         }).start();
  16.         new Thread(()->{
  17.             while(true){
  18.                 synchronized (objB){
  19.                     synchronized (objA){
  20.                         System.out.println("你在走路");
  21.                     }
  22.                 }
  23.             }
  24.         }).start();
  25.     }
  26. }

3.4生产者-消费者
    这里举例说明可以更好的理解：
        ①顾客来到餐厅发现没有吃的，就会等待wait()
        ②顾客来到餐厅发现有吃的，那么就会吃掉吃的，然后通知厨师去做notify()
        ③厨师发现现在有吃的，那就等待wait()
        ④厨师发现没有吃的，那么就会做食物，然后通知顾客notify()
    生产者-消费者主要解决了让多个线程按照一定的次序来协作完成某个功能
    代码实现主要使用三个方法：wait() notify() notifyAll();
    注意：这三个方法的调用者都是锁对象

附上代码如下：

  1. //桌子类，存放共享资源
  2. public class Desk {
  3.     //定义一个flag表示桌子上是否有食物
  4.     private boolean flag;
  5.     //定义食物数量
  6.     private int FoodCount;
  7.     //定义共用的锁
  8.     private final Object Lock = new Object();
  9.  
  10.     public Desk() {
  11.         this(false,10);
  12.     }
  13.  
  14.     public Desk(boolean flag, int foodCount) {
  15.         this.flag = flag;
  16.         FoodCount = foodCount;
  17.     }
  18.  
  19.     public boolean isFlag() {
  20.         return flag;
  21.     }
  22.  
  23.     public void setFlag(boolean flag) {
  24.         this.flag = flag;
  25.     }
  26.  
  27.     public int getFoodCount() {
  28.         return FoodCount;
  29.     }
  30.  
  31.     public void setFoodCount(int foodCount) {
  32.         FoodCount = foodCount;
  33.     }
  34.  
  35.     public Object getLock() {
  36.         return Lock;
  37.     }
  38.  
  39.     @Override
  40.     public String toString() {
  41.         return "Desk{" +
  42.                 "flag=" + flag +
  43.                 ", FoodCount=" + FoodCount +
  44.                 ", Lock=" + Lock +
  45.                 '}';
  46.     }
  47. }
  48. //消费者类（顾客)
  49. public class Foodie extends Thread{
  50.     private Desk desk;
  51.     public Foodie(Desk desk) {
  52.         this.desk = desk;
  53.     }
  54.  
  55.     @Override
  56.     public void run() {
  57.         while(true){
  58.             synchronized (desk.getLock()){
  59.                 if(desk.getFoodCount() == 0){
  60.                     break;
  61.                 }else{
  62.                     if(desk.isFlag()){//代表桌子上有食物
  63.                         System.out.println("吃货正在吃倒数第"+desk.getFoodCount()+"个食物");
  64.                         desk.setFlag( false);//吃完之后将flag变为flase表示桌子上没有食物了
  65.  
  66.                         //Desk.FoodCount--;//食物数量减一
  67.                         desk.setFoodCount(desk.getFoodCount()-1);
  68.  
  69.                         desk.getLock().notifyAll();//唤醒等待的线程
  70.                     }else{
  71.                         try {
  72.                             desk.getLock().wait();//如果为false，说明没有食物，那么进入等待状态，释放掉锁
  73.                         } catch (InterruptedException e) {
  74.                             e.printStackTrace();
  75.                         }
  76.                     }
  77.                 }
  78.             }
  79.         }
  80.     }
  81. }
  82. //生产者类（厨师）
  83. public class Cooker extends Thread{
  84.     private Desk desk;
  85.     public Cooker(Desk desk) {
  86.         this.desk = desk;
  87.     }
  88.  
  89.     @Override
  90.     public void run() {
  91.         while(true){
  92.             synchronized (desk.getLock()){
  93.                 if(desk.getFoodCount() == 0){
  94.                     break;
  95.                 }else{
  96.                     if(!desk.isFlag()){
  97.                         System.out.println("厨师正在做倒数第"+desk.getFoodCount()+"个食物，还剩"+(desk.getFoodCount()-1)+"个食物");
  98.                         desk.setFlag(true);
  99.                         desk.getLock().notifyAll();
  100.                     }else{
  101.                         try {
  102.                             desk.getLock().wait();
  103.                         } catch (InterruptedException e) {
  104.                             e.printStackTrace();
  105.                         }
  106.                     }
  107.                 }
  108.             }
  109.         }
  110.     }
  111. }
  112. //测试类
  113. public class Test {
  114.     public static void main(String[] args) {
  115.         Desk desk = new Desk();
  116.         Foodie f = new Foodie(desk);
  117.         Cooker c = new Cooker(desk);
  118.         f.start();
  119.         c.start();
  120.     }
  121. }

3.5阻塞队列

     3.5.1阻塞队列的使用
        阻塞出现的原因：程序去完成一个功能时，由于某种原因，现在无法完成，程序会停住(后面的代码就不能再执行了)，直到该功能完成为止。
        阻塞队列结合生产者-消费者使用可以大大提高代码效率，并且不需要加锁，因为阻塞队列的底层就是 锁+wait+notify
     3.5.2阻塞队列的创建和方法
        BlockingQueue:
            ArrayBlockingQueue(int capacity)
             LinkedBlockingQueue();
        方法：
            往阻塞队列中放元素：put
            从阻塞队列中取元素：take
     3.5.3分析
            在消费者-生产者机制中使用阻塞队列，相当于给生产者提供了一个可以存放多个产品的队列，它生产了产品就放到阻塞队列中，不必等待消费者消费了产品之后再唤醒它再去生产下一个产品；而消费者也同理，它可以直接从阻塞队列中取产品，不用等生产者一个一个生产。

附上代码如下：

  1. import java.util.concurrent.ArrayBlockingQueue;
  2. //生产者类
  3. public class Cooker extends Thread{
  4.     private ArrayBlockingQueue<String> arrayBlockingQueue;
  5.     public Cooker(ArrayBlockingQueue<String> arrayBlockingQueue) {
  6.         this.arrayBlockingQueue = arrayBlockingQueue;
  7.     }
  8.  
  9.     @Override
  10.     public void run() {
  11.         while (true){
  12.             try {
  13.                 arrayBlockingQueue.put("汉堡包");
  14.                 System.out.println("往阻塞队列中放一个汉堡包");
  15.             } catch (InterruptedException e) {
  16.                 e.printStackTrace();
  17.             }
  18.         }
  19.     }
  20. }
  21. //消费者类
  22. import java.util.concurrent.ArrayBlockingQueue;
  23.  
  24. public class Foodie extends Thread{
  25.     private ArrayBlockingQueue<String> arrayBlockingQueue;
  26.     public Foodie(ArrayBlockingQueue<String> arrayBlockingQueue) {
  27.         this.arrayBlockingQueue = arrayBlockingQueue;
  28.     }
  29.  
  30.     @Override
  31.     public void run() {
  32.         while (true){
  33.             try {
  34.                 String food = arrayBlockingQueue.take();
  35.                 System.out.println("从阻塞队列拿到了一个"+food);
  36.             } catch (InterruptedException e) {
  37.                 e.printStackTrace();
  38.             }
  39.         }
  40.     }
  41. }
  42. //测试类
  43. import java.util.concurrent.ArrayBlockingQueue;
  44.  
  45. public class Test {
  46.     public static void main(String[] args) {
  47.         ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(1);
  48.  
  49.         Cooker c = new Cooker(arrayBlockingQueue);
  50.         Foodie f = new Foodie(arrayBlockingQueue);
  51.  
  52.         c.start();
  53.         f.start();
  54.     }
  55. }

3.6线程的状态

        线程的状态有6种，分别是：
              new:Thread对象new好之后的状态
              runnable:Thread对象调用.start方法后
              blocked:阻塞
              waiting:等待
              timed_waiting:计时等待
             terminated:死亡

3.7线程池

    3.7.1概念
        线程池指存放线程的容器，大大提高了效率，不需要每需要执行一个任务就创建一个线程，执行完成后销毁线程；线程池的存在可以使线程任务结束后回到线程池，下次任务执行再直接使用
    3.7.2Executors默认线程池
      

  1.  Executors:
  2.         static ExecutorService newCachedThreadPool();
  3.         这是一个静态方法，可以通过Executors这个类直接调用，返回一个ExecutorService对象
  4.          ExecutorService提供了这些方法：
  5.             submit(Runable r);//接收一个Runable接口的实现类，可以使用Lambda表达式
  6.             submit(Callable c);//接收一个Callable接口的实现类，可以使用Lambda表达式
  7.             shutdown();//摧毁线程池


    3.7.3Executors创建指定上限的线程池
        要想创建指定线程池容量的方法：
            

  1. ExecutorService newFixedThreadPool(int nTheads);
  2.             ScheduledExecutorService newScheduledThreadPool(int corePoolSize)  
  3.             ScheduledExecutorService newSingleThreadScheduledExecutor()
  4.             ExecutorService newSingleThreadExecutor()

3.7.4自己直接创建线程池
        上面的创建都是先创建Service，我们也可以直接创建线程池对象：
          

  1.  public ThreadPoolExecutor(    
  2.                 int corePoolSize,//核心线程数量 2
  3.                 int maximumPoolSize,//最大线程数量 5
  4.                 long keepAliveTime,//空闲线程最大的空闲时间
  5.                 TimeUnit unit,//空闲时间单位
  6.                 BlockingQueue<Runnable> workQueue, //阻塞队列，存放等待执行的任务
  7.                 ThreadFactory threadFactory,//造线程的工厂  
  8.                 RejectedExecutionHandler handler//任务超过最大线程数+阻塞队列容量，拒绝的策略)


        3.7.4.1拒绝策略
                当任务超过最大线程数+阻塞队列容量会被拒绝，默认的拒绝策略是丢弃任务，并抛出异常
         3.7.4.2非默认任务拒绝策略
               

  1. ThreadPoolExecutor.DiscardPolicy:
  2.                 *丢弃任务；
  3.                 ThreadPoolExecutor.DiscardOldestPolicy:
  4.                 *丢弃任务队列中等待时间最长的任务，再把最新的任务添加到队列中
  5.                 ThreadPoolExecutor.CallerRunsPolicy:
  6.                 *谁提交的这个任务，谁来执行这个任务；

附上线程池相关代码：

  1. public class MyThreadPoolDemo1 {
  2.     public static void main(String[] args) {
  3.         //创建线程池对象
  4.         ExecutorService executorService = Executors.newCachedThreadPool();
  5.         //使用Lambda表达式来创建函数式接口的对象
  6.         executorService.submit(()->{
  7.             System.out.println(Thread.currentThread().getName()+"正在运行");
  8.         });
  9.  
  10.  
  11.         //使用Lambda表达式来创建函数式接口的对象
  12.         executorService.submit(()->{
  13.             System.out.println(Thread.currentThread().getName()+"正在运行");
  14.         });
  15.  
  16.         executorService.submit(()->{
  17.             System.out.println(Thread.currentThread().getName()+"正在运行");
  18.         });
  19.  
  20.         executorService.shutdown();
  21.  
  22.  
  23.     }
  24. }

上边是通过Executors默认创建线程池，下边是自己new的线程池：

  1. public class MyThreadPoolDemo3 {
  2.     public static void main(String[] args) {
  3.         ThreadPoolExecutor pool = new ThreadPoolExecutor(
  4.                 3,//核心线程数量
  5.                 5,//总线程数量
  6.                 2,//临时线程的空闲时间
  7.                 TimeUnit.SECONDS,//空闲时间单位
  8.                 new ArrayBlockingQueue<>(10),//阻塞队列
  9.                 Executors.defaultThreadFactory(),//创建线程的线程工厂
  10.                 new ThreadPoolExecutor.AbortPolicy());//当等待的线程超过总量+阻塞队列时的拒绝策略
  11.  
  12.         pool.submit(()->{
  13.             System.out.println(Thread.currentThread().getName()+"RUNNING....");
  14.         });
  15.         pool.shutdown();
  16.     }
  17. }

3.8volatile-问题
        volatile关键字主要解决了内存不可见问题，就是当多个线程同时操作共享数据时，如果其中一个修改了共享数据，另外的线程无法及时获取到新的数据。
        使用volatile关键字修饰变量后，那么有关该变量操作的代码，就不会被机器指令替换
         内存不可见问题：jvm在执行java代码时，针对反复执行的代码，就会把这些代码标记为热点代码，这些热点代码在执行指定量次(10000)，jvm会使用jit及时编译，把之前这些class指令替换为机器指令，反复执行的时候就再也不会读取新的数据了
        也可以使用synchronized解决内存不可见问题，因为synchronized中的代码会强制查看共享内存中的数据；
3.9原子性
        原子性指不可分割，举例：count++
            count++虽然看起来是一行代码，但是执行的时候对应3个指令：
                1.读取共享内存数据到变量副本；
                2.对变量副本中的数据进行自增1；
                3.把变量副本中的数据写入到共享内存；
                所以当多个线程执行时，count++可能造成线程安全问题，
                可以使用synchronized解决原子性导致的线程安全问题，将count++变成不可分的，但是synchronized是重量级锁，性能较低，也可以使用volatile+cas算法解决线程安全问题。

    3.9.1AtomicInteger
        jdk在并发包中提供了大量的Atomicxxx类，专门用于在多线程环境下编程，AtomicInteger是比较常用的一种：
      

  1. AtomicIneger();
  2.         int get(); //获取值
  3.         int getAndIncrement();//以原子方式将当前值加1，这里返回的是自增前的值
  4.         int incrementAndGet();// 以原子方式将当前值加1，这里返回的是自增后的值
  5.         int addAndGet(int delta);//以原子方式将参数与对象中的值相加，并返回结果
  6.         int getAndSet(int delta);//以原子方式设置为newValue的值，并返回旧值。


    3.9.2AtomicInteger-内存解析
        volatile关键字加CAS算法可以解决内存不可见问题
        CAS算法原理：在对共享数据进行操作时，把原来的旧值记录下来，在自己的栈内对数据进行操作之后要写入内存之前，比较现在内存中的值跟原来的旧值一样，那么说明没有其他线程对共享数据进行操作，那么对其进行修改（将修改的值写入内存）；如果旧值不一样了，那么说明有其他线程对共享数据进行过其他操作了，那么需要再次获取内存的新值，再次进行操作，这个重新获取就是自旋。
   

  1.  伪代码：
  2.         while(true){
  3.             ①读取内存值，赋值给旧值;
  4.             ②给旧值加1，得到新值;
  5.             ③if(旧值==内存值){
  6.                 内存值=新值;
  7.                 break;
  8.             }
  9.         }

3.10并发工具类

    3.10.1HashTable
        HashTable是线程安全的，因为它的底层方法都加了synchronized关键字，在操作共享数据时，将整个hash表都锁
    3.10.2并发工具类-ConcurrentHashMap
        ConcurrentHashMap继承了HashMap，所以父类的方法都是可以使用的
        ConcurrentHashMap在JDK1.7中，有一个长度为16的不可变的数组，在每个数组位置上有一个可扩容小数组，该位置存储的数据超过小数组的加载因子，则自动扩容为原长度的2倍
        ConcurrentHashMap在JDK1.8中，采用了 CAS + synchronized 来保证并发安全性
        put方法：
        1.计算key的hash值
        2.如果当前table还没有初始化先调用initTable方法将tab进行初始化
        3.tab中索引为i的位置的元素为null，则直接使用CAS将值插入即可
        4.当前正在扩容
        6.若当前为红黑树，将新的键值对插入到红黑树中
        7.插入完键值对后再根据实际大小看是否需要转换成红黑树
        8.对当前容量大小进行检查，如果超过了临界值（实际大小*加载因子）就需要扩容
    3.10.3ConcurrentHashMap的高性能
        在操作数据时只锁住索引处的链表，不像HashTable锁住一整张表
    3.10.4并发工具类-CountDownLatch
        如果一个线程需要等待其他多个线程执行完毕以后才能执行，可以使用CountDownLatch
        public CountDownLatch(int count)：//让当前线程等待，计数器为0时唤醒
        public void await():
        public void countDown():

       附上完整代码：

  1. //这里写了一个妈妈要等待孩子都吃完饺子才收拾碗筷的案例
  2. import java.util.concurrent.CountDownLatch;
  3. //孩子线程
  4. public class ChildrenRunnable implements Runnable{
  5.     private CountDownLatch countDownLatch;
  6.     private int number;
  7.  
  8.     public ChildrenRunnable(CountDownLatch countDownLatch, int number) {
  9.         this.countDownLatch = countDownLatch;
  10.         this.number = number;
  11.     }
  12.  
  13.     @Override
  14.     public void run() {
  15.         for (int i = 1; i <= number; i++) {
  16.             System.out.println(Thread.currentThread().getName()+"正在吃第"+i+"个饺子");
  17.         }
  18.         countDownLatch.countDown();
  19.     }
  20. }
  21. import java.util.concurrent.CountDownLatch;
  22. //妈妈线程
  23. public class MotherRunnable implements Runnable{
  24.     private CountDownLatch countDownLatch;
  25.     public MotherRunnable(CountDownLatch countDownLatch) {
  26.         this.countDownLatch = countDownLatch;
  27.     }
  28.  
  29.     @Override
  30.     public void run() {
  31.         try {
  32.             countDownLatch.await();
  33.         } catch (InterruptedException e) {
  34.             e.printStackTrace();
  35.         }
  36.         System.out.println("妈妈去收拾碗筷了");
  37.     }
  38. }
  39. import java.util.concurrent.CountDownLatch;
  40.  
  41. public class MyCountDownLatchDemo {
  42.     public static void main(String[] args) {
  43.  
  44.         CountDownLatch countDownLatch = new CountDownLatch(3);//这里表示有三个线程要等待
  45.         MotherRunnable mr = new MotherRunnable(countDownLatch);
  46.  
  47.         new Thread(mr).start();
  48.  
  49.         new Thread(new ChildrenRunnable(countDownLatch,7),"小黑").start();
  50.         new Thread(new ChildrenRunnable(countDownLatch,9),"小红花").start();
  51.         new Thread(new ChildrenRunnable(countDownLatch,11),"小狗").start();
  52.     }
  53. }

    3.10.5并发工具类-Semaphore

         限制资源的执行量时 使用Semaphore
         public Semaphore(int permits)
         public void acquire()//获取信号量----阻塞方法
         public void release()//释放信号量

完整代码：

  1. //这里模拟一个路口同时只允许三辆车通过，必须拿到通行证才能通过，通过后归还通行证，然后别的车才能拿到通行证
  2. public class MySemaphoreRunnable implements Runnable{
  3.     //获取管理员对象
  4.     private Semaphore semaphore = new Semaphore(3);
  5.     @Override
  6.     public void run() {
  7.         try {
  8.             semaphore.acquire();//相当于获取通行证
  9.             System.out.println("拿到通行证，可以通行");
  10.             Thread.sleep(2000);
  11.             System.out.println("归还通行证");
  12.             semaphore.release();
  13.         } catch (InterruptedException e) {
  14.             e.printStackTrace();
  15.         }
  16.     }
  17. }
  18. public class MySemaphoreDemo {
  19.     public static void main(String[] args) {
  20.         MySemaphoreRunnable msr = new MySemaphoreRunnable();
  21.         for (int i = 0; i < 100; i++) {
  22.             new Thread(msr).start();
  23.         }
  24.     }
  25. }

 

原文链接:https://blog.csdn.net/liuhang_1996/article/details/114677232



所属网站分类: 技术文章 > 博客

作者：Hdhhd

链接：http://www.javaheidong.com/blog/article/114285/5b518fa69e3134f9e57f/

来源：java黑洞网

任何形式的转载都请注明出处,如有侵权 一经发现 必将追究其法律责任

6 0
收藏该文
已收藏

评论内容：(最多支持255个字符)




程序员的那些事(new) 更多>

2022年最受欢迎的8大编程语言

为什么都说程序员找不到女朋友，但是身边程序猿的却没一个单身的

程序员被开除，老板：“有你参与的项目全黄了！”

笑话：一个测试工程师走进一家酒吧

趣图：程序员头疼的4种原因

笑话：面试官：请拿出一段体现你水平的代码。我： sudo rm -rf /*面试官：这体现了你哪方面能力？

java精选：SSO单点登录】JWT入门概述&&残留的安全问题

程序人生：程序员如何实现财富自由？

找工作千万不要找外包？BAT互联网大厂外包亲身经历

程序员的工资这么高，为什么还会有人离职？

电子书(new)

java jdk8 学习笔记

深入剖析Tomcat pdf下载

Java与模式 pdf下载

深入理解Java虚拟机：JVM高级特性与最佳实践(第2版) pdf 下载

数据结构与算法分析：Java语言描述(原书第3版) pdf  下载

Java并发编程实战 中文版 PDF扫描版[9MB]

数据结构与算法分析：Java语言描述(原书第3版) 中文完整pdf扫描版[47MB] 附源码

Hadoop权威指南 pdf下载

重构 改善既有代码的设计 pdf下载

JAVA编程思想 pdf下载

脚本(new)

输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值

求 a+aa+aaa+.......+aaaaaaaaa=?

输出所有的水仙花数，把谓水仙花数是指一个数3位数，其各各位数字立方和等于其本身，

利用for循环打印 9*9 表?

编写程序求 1+3+5+7+……+99 的和值。

给定一个百分制的分数，输出相应的等级

编写程序，判断给定的某个年份是否是闰年

一些有趣的java小程序

菱形的图形生成器，2到100以内的质数-java实用小程序

java代码游戏编写

博客(new)

【Java 22 | 7】 深入解析Java 22 ：密封类（Sealed Classes）增强详解

Java 多线程（三）—— 死锁

JSON parse error: Cannot deserialize value of type `java.util.Date` from String “2024-09-19 10:40:40

Java毕业设计：Java河南郑州景区景点买票购票系统毕业设计源代码作品和开题报告

Android Studio开发学习（一、用户登录）

华为OD机试 - 处理器问题（Java & JS & Python & C & C++）

C++之多态的深度剖析

Java 继承

JavaScript-sort()排序

【面试宝典】Java中创建线程池的几种方式以及区别

视频教程(new)

由浅入深，全面解析ThreadLocal

超全面讲解Spring Cloud Alibaba技术栈，java视频教程下载

三天全面系统学习ZooKeeper

2020年JavaSE强化系列教程泛型全剖析，java视频教程下载

详讲编码与解码，灵活解决乱码难题，java 视频教程下载

2020年抗疫之作java基础进阶13天

系统学习让你轻松定义java类加载器-java视频教程下载

真小白福音，完全从0带你掌握计算机与编程基础

java零基础入门到精通（2019版）

2020JAVA基础-深入系统的学习数据结构与算法

项目实战(new)

JSP+SSM+Mysql实现的学生成绩管理系统

JSP+Structs+JDBC+mysql实现的诚欣电子商城

JSP+SSH+Mysql+DBCP实现的租车系统

博客系统java项目

这是一个在线考试系统,java项目实战源码下载

简单状态机

Java Web编程课程中开发的项目

银行账户项目样本 用Java完成的一个简单项目

一个使用Java开发在线概述用户管理平台

JAVAWeb项目 JAVA-WEB开发的一些练手项目，这些也适合初学者进行练习

问答(new)

java.security.AccessControlException：访问被拒绝（“java.util.PropertyPermission” “jna.boot.library.path” “读取”）

Java 测试：通过运行代码大量生成模拟对象

CacheBuilder 与 redis 结合使用

如何在多个 PU 之间最好地共享实体类/DAO？

读取和替换字符串中的整数

具有行数据网关的注册表模式

正则表达式匹配组

将 Heroku Cedar 模型映射到多线程应用程序

JNLP 通过文件加载 Sigar 本机库：但不通过 http：

Jasypt encrypted String not being able to decrypt on another machine

游戏(new)

2人对战游戏，java游戏

java小游戏-数学英雄

java游戏-蛙人

经典骰子游戏,java游戏源码下载

一些java小游戏

java小游戏-抓住这只球

二十一点，java小游戏源码下载

java小游戏集合下载

java五子棋游戏源码下载

java贪吃蛇游戏

其他资源(new)

某公司的雇员分为以下若干类： Employee：这是所有员工总的父类，属性：员工的姓名和生日月份。 方法：getSalary(int month) 根据参数月份来确定工资，如果该月员工过生日，

判断随机整数是否是素数 产生100个0-999之间的随机整数，然后判断这100个随机整数哪些是素数，哪些不是？

完成九宫格程序

. 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值

歌德巴赫猜想,任何一个大于六的偶数可以拆分成两个质数的和

在屏幕上打印出n行的金字塔图案，如，若n=5,则图案如下

计算圆周率

利用程序输出如下图形:

求 2/1+3/2+5/3+8/5+13/8.....前20项之和？

Nutch入门教程 pdf下载