标签: semaphore

我们有3个以不同优先级运行的任务:A(120),B(110),C(100).A采用带有Inversion Safe标志的互斥量信号量.任务B执行semTake,这会导致任务A的优先级提升到110.之后,任务C执行semTake.任务A的优先级现在是100.

此时,A释放信号量,C抓取它.我们注意到A的优先级没有回到原来的优先级120.不应该立即恢复A的优先级吗？

根据我的理解,当一个过程进入一个关键部分时,没有其他过程可以同时进入.但是我通过一个程序看到它不是.

我创建过程A,子过程B.孩子进入临界区,然后睡觉,同时我很惊讶地看到父母也进入了关键部分,而孩子则睡觉.这怎么可能？在关键部分同时进行2个过程？

enter code here
#include <semaphore.h>
#include <unistd.h>
#include <stdio.h>

sem_t sem;
int shared=0;
int pid;

void func()
{
 sem_trywait(&sem);
 if(pid==0)printf("Child entered\n");
 else if(pid>0)printf("Parent entered\n");
 sleep(2);
 shared++;
 sem_post(&sem);
 if(pid==0)printf("Child exited\n");
 else if(pid>0)printf("Parent exited\n");
}

int main()
{
 pid=fork();
 sem_init(&sem,1,0);
 if(pid==0){
  printf("In child\n");
  func();
 }
 else {
 func();
}
}
Output:
 [root@dhcppc0 semaphore]# gcc semaphore1.c -lrt
 [root@dhcppc0 semaphore]# ./a.out
  In child
  Child entered
  Parent entered

  <pause 2 secs>

  Child exited
  Parent exited

我目前正在使用 win32 API 用 C 编程。
我想知道如何永久删除或取消互斥锁和信号量。
我该怎么做，直到现在我在 MSDN 中还没有找到任何关于它的信息。
谢谢！

我正在尝试创建一个演示信号量使用的小程序。我创建了 2 个线程，运行 Farmer 的两个实例：一个以字符串“north”作为参数，另一个以“south”为参数。它们似乎同时完成了 1 个线程而不是 2 个线程完成（如输出所示：

农民过桥，向北
农民过桥，向南
农民过桥，现在向北
农民过桥，现在向南

谁能告诉我我在这里做错了什么？

import java.util.concurrent.Semaphore;
public class Farmer implements Runnable
{
    private String heading;
    private final Semaphore bridge = new Semaphore(1);
    public Farmer(String heading)
    {
        this.heading = heading;
    }

    public void run() 
    {
        if (heading == "north")
        {
            try 
            {
                //Check if the bridge is empty
                bridge.acquire();
                System.out.println("Farmer going over the bridge, heading north");
                Thread.sleep(1000);
                System.out.println("Farmer has crossed the bridge and is now heading north");
                bridge.release();
            } 
            catch (InterruptedException …

我正在尝试创建许多不同的线程,这些线程需要等待所有线程创建才能执行任何操作.这是一个大型程序的一小部分,我只是试图采取步骤.在创建每个线程时,它立即被信号量阻塞.在创建了所有线程之后,我遍历并释放所有线程.然后,我希望每个线程打印出它的线程号,以验证它们都等待.我只允许使用另一个信号量一次打印一个线程.

我遇到的问题是虽然我创建了#1-10的线程,但是一个线程打印出它是#11.此外,一些主题说他们的数字与另一个相同.是我的传递threadID中的错误还是我的同步中的错误？

这是相关代码:

//Initialize semaphore to 0. Then each time a thread is spawned it will call
    //semWait() making the value negative and blocking that thread. Once all of the
    //threads are created, semSignal() will be called to release each of the threads
     sem_init(&threadCreation,0,0);


     sem_init(&tester,0,1);


    //Spawn all of the opener threads, 1 for each valve
    pthread_t threads[T_Valve_Numbers];
    int check;

    //Loop starts at 1 instead of the standard 0 so that numbering of valves
    //is somewhat more logical. 
    for(int i =1; …

CountDownLatch in java是一个高级同步实用程序,用于防止特定线程在所有线程准备就绪之前开始处理.

但是,Semaphore完全可以做同样的事情.那么,有什么优点CountDownLatch呢？

还有一个问题:如果CountDownLatch确实有一些优点,为什么它只被设计为使用一次？我认为添加set方法来重置计数很容易.

这有效:

int _counter;
readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

async void Button_Click(object sender, RoutedEventArgs e)
{
    if (_semaphore.Wait(0))
    {
        Title = $"{ ++_counter}";
        await Task.Delay(1000); // simulate work
        Title = $"{ --_counter}";
        _semaphore.Release();
    }
}

首次单击其他按钮后,将忽略单击,直到工作完成.Tittle可以是1或0.

这不起作用

void Button_Click(object sender, RoutedEventArgs e)
{
    if (_semaphore.Wait(0))
    {
        Test(); // moving code into separate method
        _semaphore.Release();
    }
}

async void Test()
{
    Title = $"{ ++_counter}";
    await Task.Delay(1000); // simulate work
    Title = $"{ --_counter}"; …

我需要同时完成5个任务,一次执行最多2个任务.因此,一旦某个任务完成,下一个应该运行,直到没有任务待处理.

我正在使用LB的解决方案,该解决方案涉及使用信号量来跨任务同步.

void LaunchTaskPool ()
    {
        SemaphoreSlim maxThreadSemaphore = new SemaphoreSlim(2); //Max 2 tasks at a time.

        for (int i = 0; i < 5; i++)                     //loop through 5 tasks to be assigned
        {
            maxThreadSemaphore.Wait();                  //Wait for the queue

            Console.WriteLine("Assigning work {0} ", i);

            Task t = Task.Factory.StartNew(() =>
            {
                DoWork(i.ToString());                   // assign tasks
            }, TaskCreationOptions.LongRunning
                )
                .ContinueWith(
                (task) => maxThreadSemaphore.Release()  // step out of the queue
                );
        }

    }

    void DoWork(string workname)
    { …

最近我发现Linux内核中的Sleep系统调用会将当前调用线程挂起到挂起/阻塞状态,这意味着他们不会在上述时间过去之前使用CPU.- 完全理解.

现在来到互斥和信号量,

互斥锁:

acquire() {
while (!available)
; // busy wait    --> my doubt
available = false;;
}

release() {
available = true;
}

信号量锁定:

wait(S) {
while (S <= 0)
; // busy wait --> my doubt
S--;
}
signal(S) {
S++;
}

PS:这些代码片段取自ABRAHAM SILBERSCHATZ的"操作系统概念-9版"

我的问题:

我知道忙等待不是解决同步问题的有效方法,但是从上面提到的代码片段我怀疑使用互斥和信号量会在忙碌的等待中结束？(尽管互斥体和信号量被广泛用于解决大多数系统问题).

这让我觉得使用互斥锁和信号量不是解决同步问题的有效方法, 因为它会占用CPU周期(因为它不会导致挂起状态而是在while循环中旋转).

简而言之: 互斥和信号量是否会等待而不是将等待的线程线程置于挂起状态？

提前致谢 !!.如果我的理解错了,请纠正我!

我的多线程代码存在问题,希望有人可以帮助我.

我希望在控制台上打印所有文件和文件夹,从作为参数给出的文件夹开始.我使用此函数进行枚举:

void enumerate(char* path) {
    HANDLE hFind;
    WIN32_FIND_DATA data;

    char *fullpath = new char[strlen(path) - 1];
    strcpy(fullpath, path);
    fullpath[strlen(fullpath) - 1] = '\0';

    hFind = FindFirstFile(path, &data);
    do {
        if (hFind != INVALID_HANDLE_VALUE) {
            if (strcmp(data.cFileName, ".") != 0 && strcmp(data.cFileName, ".."))
            {
                EnterCriticalSection(&crit);
                queue.push(data.cFileName);
                LeaveCriticalSection(&crit);
                ReleaseSemaphore(semaphore, 1, NULL);
                if (data.dwFileAttributes == FILE_ATTRIBUTE_DIRECTORY)
                {
                    strcat(fullpath, data.cFileName);
                    strcat(fullpath, "\\*");
                    enumerate(fullpath);
                }
            }
        }
    } while (FindNextFile(hFind, &data));
    FindClose(hFind);

    return;
}

当我找到文件或文件夹时,我想将其添加到全局队列中,并让我的工作线程将其打印到控制台.我的工作线程功能是:

DWORD WINAPI print_queue(LPVOID param) {
    while (1) {
        WaitForSingleObject(semaphore, …