JAVA控制线程并发数量

JAVA控制线程并发数量方法主要有，限制一个线程使用（synchronized），限制指定数量的线程并发使用（Semaphore）

一、JAVA控制线程主要有限制当前方法只能被一个线程访问，方法主要为：synchronized()，当一个方法用synchronized修饰之后，该方法就只能被一个线程使用，等于此方法的门上了一道锁，其他线程需要在“门”外等待，直到里面的线程出来了才可以继续访问。我们来看案例一体会一下。

案例一：顾客进服装店的购物过程包含三个环节，选衣服，试衣服，结账离开。其中选衣服环节和试衣服环节需要的时间为 10-30分钟不等（随机），结账离开环节5分钟，该店只有一间试衣间（不能两人同时使用）。 请编写一个程序模拟2个顾客进店购买的过程。程序执行过程中，输出每个顾客所处的环节信息。 比如，顾客1在试衣服，顾客2，在选衣服，顾客2在试衣服。

代码：

import java.util.Random;

public class ClothesShop implements Runnable{
    
    ClothesShop(){
    }
    
    public void selectclothes() {
        long time = (long)(Math.random()*20 + 10);
        System.out.println("顾客" + Thread.currentThread().getName() + "正在选择衣服, " + "时间为：" + time + " s");
        try {
            Thread.sleep(time*1000);
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
    
    //用synchronized修饰，此方法只能被一个线程使用
    public synchronized void tryclothes() {
        long time = (long)(Math.random()*20 + 10);
        System.out.println("顾客" + Thread.currentThread().getName() + "试衣服, " + "时间为：" + time + " s");
        try {
            Thread.sleep(time*1000);
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
    
    public void givemoney() {
        long time = 5;
        System.out.println("顾客" + Thread.currentThread().getName() + "正在结账, " + "时间为：" + time + " s");
        try {
            Thread.sleep(time*1000);
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
    
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(true) {
            selectclothes();
            tryclothes();
            givemoney();
            break;
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ClothesShop clothesshop = new ClothesShop();
        Thread c1 = new Thread(clothesshop,"1");
        Thread c2 = new Thread(clothesshop,"2");
        c1.start();
        c2.start();
    }

}

二、JAVA控制指定线程数量并发主要是采用Semaphore()方法。当并发线程数量达到限定数量时，就会给该方法的“门”上锁，直到一个线程出来，释放了并发线程数量，其他线程才能继续访问这个方法，进入这道“门”。我们直接看案例体会一下：

案例二：案例一改编：如果有2个试衣间，同一时间只能容纳5个乘客进店购物，选衣服和试衣服的时间都是随机的，请编程模拟。

代码：

import java.util.Random;
import java.util.concurrent.Semaphore;

public class ClothesShop2 implements Runnable{

    private static Semaphore msemaphoretryroom = new Semaphore(2);//指定线程并发数量
    private static Semaphore msemaphoreshoproom = new Semaphore(5);
    
    ClothesShop2(){
    }
    
    public void selectclothes() {
        try {
            msemaphoreshoproom.acquire();//shoproom可用数量减少
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        //availablePermits()查看当前可用的并发数数量
        //System.out.println(msemaphoreshoproom.availablePermits());
        System.out.println("顾客" + Thread.currentThread().getName() + "进来商店了");
        
        long time = (long)(Math.random()*20 + 10);
        System.out.println("顾客" + Thread.currentThread().getName() + "正在选择衣服, " + "时间为：" + time + " s");
        try {
            Thread.sleep(time*1000);
        }catch(Exception e) {
            e.printStackTrace();
        }
        
    }
    
    //用synchronized修饰，此方法只能被一个线程使用
    public void tryclothes() {
        
        try {
            msemaphoretryroom.acquire();//tryroom可用数量减少
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        long time = (long)(Math.random()*20 + 10);
        System.out.println("顾客" + Thread.currentThread().getName() + "试衣服, " + "时间为：" + time + " s");
        try {
            Thread.sleep(time*1000);
        }catch(Exception e) {
            e.printStackTrace();
        }
        
        msemaphoretryroom.release();//一个线程从tryroom中出来，释放tryroom数量
        
    }
    
    public void givemoney() {
        long time = 5;
        System.out.println("顾客" + Thread.currentThread().getName() + "正在结账, " + "时间为：" + time + " s");
        try {
            Thread.sleep(time*1000);
        }catch(Exception e) {
            e.printStackTrace();
        }
        
        msemaphoreshoproom.release();//释放shoproom数量
        System.out.println("顾客" + Thread.currentThread().getName() + "出去商店了");
    
    }
    
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(true) {
            selectclothes();
            tryclothes();
            givemoney();
            break;
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ClothesShop2 clothesshop = new ClothesShop2();
        for(int i = 1; i <= 10; i++) {
            Thread c = new Thread(clothesshop,String.valueOf(i));
            c.start();
        }
    }

}