swift信号量命令行工具项目等待组完成

似乎不要等到小组结束

let oneSem_1 = DispatchSemaphore(value: 1)
let semaphore = DispatchSemaphore(value: 4)
let semaphoreEND = DispatchSemaphore(value: 0)
var p=0
let group_2 = DispatchGroup()
var t:[Int]=[]
let MAX=1000000
for _ in 0..<MAX {
    group_2.enter()
    DispatchQueue.global().async{
        //group_2.enter()
        semaphore.wait()

        oneSem_1.wait()
        p+=1
        t.append(p)//car ressource critique, sinon pas rempli à fond
        oneSem_1.signal()

        if p == MAX{
            print("p == MAX")
            semaphoreEND.signal()
        }

        semaphore.signal()
        //group_2.leave()
    }
    group_2.leave()
}

group_2.wait()
//    semaphoreEND.wait()

//    while(p != MAX){
//        usleep(1_00_000)
//        print("p=",p)
//    }
print("END   p=\(p)  t.count=\(t.count)")

let-oneSem_1=调度信号量（值：1）
让信号量=分派信号量（值：4）
let semaphoreEND=DispatchSemaphore（值：0）
var p=0
设group_2=DispatchGroup（）
变量t:[Int]=[]
设MAX=1000000
对于0中的u..此问题的解决方案：
我把组2.leave（）放在了一个不好的地方。
像这里&&和其他像你这样的人在完成时必须把它放在异步函数中

func task(){
//    sleep(1)
    oneSem_1.wait()
    p+=1
    t.append(p)//car ressource critique, sinon pas rempli à fond
    oneSem_1.signal()
}

print("start")
for _ in 0..<MAX {
    group_2.enter()
    DispatchQueue.global().async{
        semaphore.wait()
//        print("wake up")
        task()
//        print("end")
        group_2.leave()
        semaphore.signal()
    }
}
group_2.wait()
print("END   p=\(p)  t.count=\(t.count)")

func任务（）{
//睡眠（1）
等一下
p+=1
t、 附加（p）//car ressource commission，sinon pas rempliáfound
oneSem_1.信号（）
}
打印（“开始”）
对于uu0..这个问题的另一个解决方案（没有等待组）：根据欧洲委员会

看,

let-oneSem_1=调度信号量（值：1）
让信号量=分派信号量（值：4）
var p=0
变量t:[Int]=[]
设MAX=100_000
#如果调试
打印（“调试”）
//存储对当前运行循环的引用
让runLoop=CFRunLoopGetCurrent（）
#恩迪夫
func任务（）{
//睡眠（1）
等一下
p+=1
t、 附加（p）//ressource Commission，sinon pas rempliáfound
如果p==MAX{
#如果调试
打印（“CFRunLoopStop（runLoop）”）
CFRunLoopStop（runLoop）
#否则
DispatchQueue.main.async{
打印（“CFRunLoopStop（CFRunLoopGetCurrent（））”）
CFRunLoopStop（CFRunLoopGetCurrent（））
}
#恩迪夫
}
oneSem_1.信号（）
}
对于uu in 0..此问题的另一个解决方案（无等待组）

使用Apple进程和线程>RunLoop:：根据

看,

//存储对当前运行循环的引用
var shouldKeepRunning=true
让runLoop=runLoop.current
func任务（）{
//睡眠（1）
等一下
p+=1
t、 附加（p）//ressource Commission，sinon pas rempliáfound
如果p==MAX{
打印（“p==最大值”）
//shouldKeepRunning=false//BUG！！
DispatchQueue.main.async{//METTRE-CECI
shouldKeepRunning=false
}
}
oneSem_1.信号（）
}
对于0中的uu。。RunLoop
您使用了DispatchQueue.global（）.async，块在主队列上异步执行，因此组2进入然后突然退出，并且块异步执行。我已对0中的循环代码//for u注释了所有内容。抱歉，这是可怕的代码。请学习如何处理异步数据处理。告诉我，不要问。要在CLI中运行异步代码，您需要一个runloop.CLI=命令行界面。如果我取消注释//while（p！=MAX）{//usleep（1_00_000）//print（“p=，p）//}），您认为我会得到一个运行循环吗？不，您必须显式地启动和停止运行循环。
let oneSem_1 = DispatchSemaphore(value: 1)
let semaphore = DispatchSemaphore(value: 4)
var p=0
var t:[Int]=[]
let MAX=100_000
#if DEBUG
print("DEBUG")
// Store a reference to the current run loop
let runLoop = CFRunLoopGetCurrent()
#endif

func task(){
    //sleep(1)
    oneSem_1.wait()
    p+=1
    t.append(p)//ressource critique, sinon pas rempli à fond
    if p == MAX{
        #if DEBUG
        print("CFRunLoopStop(runLoop)")
        CFRunLoopStop(runLoop)
        #else
        DispatchQueue.main.async{
            print("CFRunLoopStop(CFRunLoopGetCurrent())")
            CFRunLoopStop(CFRunLoopGetCurrent())
        }
        #endif
    }
    oneSem_1.signal()
}
for _ in 0..<MAX {
    DispatchQueue.global().async{
        semaphore.wait()
//        print("wake up")
        task()
//        print("end")
        semaphore.signal()
    }
}
// Start run loop after work has been started
print("start")
CFRunLoopRun()
print("END   p=\(p)  t.count=\(t.count)")

// Store a reference to the current run loop
var shouldKeepRunning = true
let runLoop = RunLoop.current
func task(){
    //sleep(1)
    oneSem_1.wait()
    p+=1
    t.append(p)//ressource critique, sinon pas rempli à fond
    if p == MAX{
        print("p == MAX")
//        shouldKeepRunning = false//BUG!!
        DispatchQueue.main.async{//METTRE CECI
            shouldKeepRunning = false
        }
    }
    oneSem_1.signal()
}
for _ in 0..<MAX {
    DispatchQueue.global().async{
        semaphore.wait()
        //print("wake up")
        task()
        //print("end")
        semaphore.signal()
    }
}
// Start run loop after work has been started
print("start")
while shouldKeepRunning  && runLoop.run(mode: .default, before: .distantFuture)
{
    print("WROTE ONLY ONCE")

}
print("END   p=\(p)  t.count=\(t.count)")