如何使用信号量同时执行 2 个线程答案

【问题标题】：how to execute 2 threads in the same time using semaphore如何使用信号量同时执行 2 个线程
【发布时间】：2021-01-10 22:02:18
【问题描述】：

我为 2 列火车创建了 2 个线程，第一个有 (nord-sud) 方向，第二个有 (sud-nord) 方向，所以只有一条铁路，不能满足 2 列不同方向的火车.. 所以这是我的主要课程：

 public static void main(String[] args) throws InterruptedException {        
        Semaphore sem = new Semaphore(1); 
 
        MyThread train1 = new MyThread(sem, "nord-sud"); 
        MyThread train2 = new MyThread(sem, "sud-nord"); 
         
        // stating threads 1 and train 2 
        train1.start(); 
        train2.start(); 
        train1.join();       
        train2.join();
    }

这是我的 MyThread 类扩展的 Thread 类：

class MyThread extends Thread 
{ 
    Semaphore sem; 
    String threadName; 
    public MyThread(Semaphore sem, String threadName)  
    { 
        super(threadName); 
        this.sem = sem; 
        this.threadName = threadName; 
    } 
  
    @Override
    public void run() { 
          
        // run by thread A 
        if(this.getName().equals("nord-sud")) 
        { 
            System.out.println("Starting " + threadName); 
            try 
            { 
                System.out.println(threadName + " wait for railway to enter"); 
              
                // acquiring the lock 
                sem.acquire(); 
              
                System.out.println(threadName + " have access to enter"); 
          
                // Now, accessing the shared resource. 
                // other waiting threads will wait, until this  
                // thread release the lock 
                for(int i=0; i < 5; i++) 
                { 
                    Shared.count++; 
                    System.out.println(threadName + ": " + i); 
          
                    // Now, allowing a context switch -- if possible. 
                    // for thread B to execute 
                    Thread.sleep(1000); 
                } 
            } catch (InterruptedException exc) { 
                    System.out.println(exc); 
                } 
          
                // Release the permit. 
                
                System.out.println(threadName + " left the railway "); 
                sem.release(); 
                
                
        } 
          
        // run by thread B 
        else
        { 
            System.out.println("Starting " + threadName); 
            try 
            { 
                // First, get a permit. 
                System.out.println(threadName + " wait for railway to enter"); 
              
          
                sem.acquire(); 
              
                System.out.println(threadName + " have access to enter"); 
          
                for(int i=0; i < 5; i++) 
                { 
                    Shared.count--; 
                    System.out.println(threadName + ": " + i); 
          
              
                    Thread.sleep(1000); 
                } 
            } catch (InterruptedException exc) { 
                    System.out.println(exc); 
                } 
                // Release the permit. 
                System.out.println(threadName + "left the railway"); 
                sem.release();
        } 
    } 
   
}

因此，当我在同一时期添加 2 列北南方向的火车时，我希望它们都进入铁路，因为它们具有相同的方向，只有当他意识到另一列不同方向的火车时，火车才应该等待是在铁路。那么我怎样才能同时执行 2 个线程呢？例如 train1(nord-sud)、train2(nord-sud) 和 train3(sud-nord)。所以火车 1 和火车 2 都进入铁路，火车 3 等他们离开才能进入。

【问题讨论】：

为什么是 if... else... 块？您在两个分支中运行完全相同的代码。

标签： java multithreading semaphore

【解决方案1】：

您可以为方向相近的火车创建两个权限，为不同方向的火车创建一个权限，例如：

public class Solution0 {
public static void main(String[] args) throws InterruptedException {
    String direction1 = "nord-sud";
    String direction2 = "sud-sud";
    int permissionCount;
    if (direction1.equals(direction2)){
        permissionCount = 2;
    }else {
        permissionCount = 1;
    }
    Semaphore sem = new Semaphore(permissionCount);

    MyThread train1 = new MyThread(sem, direction1);
    MyThread train2 = new MyThread(sem, direction2);

    // stating threads 1 and train 2
    train1.start();
    train2.start();
    train1.join();
    train2.join();
}

}

不同方向的输出：

Starting sud-sud
Starting nord-sud
sud-sud wait for railway to enter
nord-sud wait for railway to enter
sud-sud have access to enter
sud-sud: 0
sud-sud: 1
sud-sud: 2
sud-sud: 3
sud-sud: 4
sud-sudleft the railway
nord-sud have access to enter
nord-sud: 0
nord-sud: 1
nord-sud: 2
nord-sud: 3
nord-sud: 4
nord-sud left the railway

类似方向的输出：

Starting sud-sud
Starting sud-sud
sud-sud wait for railway to enter
sud-sud wait for railway to enter
sud-sud have access to enter
sud-sud have access to enter
sud-sud: 0
sud-sud: 0
sud-sud: 1
sud-sud: 1
sud-sud: 2
sud-sud: 2
sud-sud: 3
sud-sud: 3
sud-sud: 4
sud-sud: 4
sud-sudleft the railway
sud-sudleft the railway

【讨论】：

是的，但是如果我添加了 2 列方向相同的火车，然后又添加了另一列方向不同的火车怎么办？当两列第一列火车离开铁路时，我希望第三列也能进入。

【解决方案2】：

在这种情况下，您应该为 nord-sud 和 sud-nord 列车分别建立一个列表和一个线程。列表线程应该负责获取信号量，然后在获取时它们应该启动各个火车线程（大概在第一个线程之后添加延迟，这样火车就不会同时运行）。然后列表线程应在每个火车线程上调用 Thread.join()（尽管实际上可能只需要加入最后一个线程），然后在最后一列火车到达后释放信号量。

【讨论】：