＜多线程＞LeetCode题目汇总

最新推荐文章于 2022-01-13 16:10:48 发布
最新推荐文章于 2022-01-13 16:10:48 发布
阅读量249 收藏 3
点赞数
分类专栏： 多线程 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42426714/article/details/109532333
版权

1.按序打印

1114.按序打印
在这里插入图片描述
法1：CountDownLatch

用来控制一个或者多个线程等待多个线程。


维护了一个计数器 cnt，每次调用 countDown() 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 await()
方法而在等待的线程就会被唤醒。

在这里插入图片描述

    CountDownLatch stage1 = new CountDownLatch(1);
    CountDownLatch stage2 = new CountDownLatch(1);
	
    public void first(Runnable printFirst) throws InterruptedException {
        printFirst.run();
        stage1.countDown();
    }

    public void second(Runnable printSecond) throws InterruptedException {
        stage1.await();
    	printSecond.run();
        stage2.countDown();
    }

    public void third(Runnable printThird) throws InterruptedException {
        stage2.await();
        printThird.run();
    }

法2：Semaphore
Semaphore 类似于操作系统中的信号量，可以控制对互斥资源的访问线程数。

    Semaphore stage1 = new Semaphore(1);
    Semaphore stage2 = new Semaphore(0);
    Semaphore stage3 = new Semaphore(0);
	
    public void first(Runnable printFirst) throws InterruptedException {
	stage1.acquire();
        printFirst.run();
        stage2.release();
    }

    public void second(Runnable printSecond) throws InterruptedException {
    	stage2.acquire();
    	printSecond.run();
    	stage3.release();
    }

    public void third(Runnable printThird) throws InterruptedException {
    	stage3.acquire();
        printThird.run();
    }

法3：Lock

java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。


相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。

使用 Lock 来获取一个 Condition 对象。

    Lock lock = new ReentrantLock();
    volatile int stage = 1;
    Condition stage2 = lock.newCondition();
    Condition stage3 = lock.newCondition();
	
    public void first(Runnable printFirst) throws InterruptedException {
	lock.lock();
	try {
		printFirst.run();
		stage = 2;
		stage2.signal();
	}finally {
		lock.unlock();
	}
    }

    public void second(Runnable printSecond) throws InterruptedException {
    	lock.lock();
	try {
		while(stage!=2) {
			stage2.await();
		}
		printSecond.run();
		stage = 3;
		stage3.signal();
	}finally {
		lock.unlock();
	}
    }

    public void third(Runnable printThird) throws InterruptedException {
    	lock.lock();
	try {
		while(stage!=3) {
			stage3.await();
		}
		printThird.run();
	}finally {
		lock.unlock();
	}
    }

法4：无锁

    volatile int stage = 1;
	
    public void first(Runnable printFirst) throws InterruptedException {
	printFirst.run();
	stage = 2;
    }

    public void second(Runnable printSecond) throws InterruptedException {
    	while(stage!=2);
	printSecond.run();
	stage = 3;
    }

    public void third(Runnable printThird) throws InterruptedException {
    	while(stage!=3);
	printThird.run();
    }

法5：CyclicBarrier

用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。

和 CountdownLatch 相似，都是通过维护计数器来实现的。线程执行 await() 方法之后计数器会减1，并进行等待，直到计数器为 0，所有调用 await() 方法而在等待的线程才能继续执行。

CyclicBarrier 和 CountdownLatch 的一个区别是，CyclicBarrier 的计数器通过调用 reset()方法可以循环使用，所以它才叫做循环屏障。

CyclicBarrier 有两个构造函数，其中 parties 指示计数器的初始值，barrierAction在所有线程都到达屏障的时候会执行一次。

在这里插入图片描述

    CyclicBarrier cb1 = new CyclicBarrier(2);
    CyclicBarrier cb2 = new CyclicBarrier(2);
	
    public void first(Runnable printFirst) throws InterruptedException {
	printFirst.run();
	try {
		cb1.await();
	} catch (BrokenBarrierException e) {
		e.printStackTrace();
	}
    }

    public void second(Runnable printSecond) throws InterruptedException{
    	try {
		cb1.await();
		printSecond.run();
		cb2.await();
	} catch (BrokenBarrierException e) {
		e.printStackTrace();
	}    	
    }

    public void third(Runnable printThird) throws InterruptedException{
    	try {
		cb2.await();
	} catch (BrokenBarrierException e) {
		e.printStackTrace();
	}
	printThird.run();
    }

2.交替打印FooBar

1115.交替打印FooBar
在这里插入图片描述

法1：

class FooBar {
    private int n;

    public FooBar(int n) {
        this.n = n;
    }
    Semaphore stage1 = new Semaphore(1);
    Semaphore stage2 = new Semaphore(0);

    public void foo(Runnable printFoo) throws InterruptedException {     
        for (int i = 0; i < n; i++) {
            stage1.acquire();
        	printFoo.run();
            stage2.release();     	
            } 
    }
    
    public void bar(Runnable printBar) throws InterruptedException {       
        for (int i = 0; i < n; i++) {
            stage2.acquire();
            printBar.run();
            stage1.release();
        }
    }
}

法2：公平锁

class FooBar {
    private int n;

    public FooBar(int n) {
        this.n = n;
    }

    Lock lock = new ReentrantLock(true);
    volatile boolean permitFoo = true;

    public void foo(Runnable printFoo) throws InterruptedException {
        
        for (int i = 0; i < n; ) {
            lock.lock();
            try {
            	if(permitFoo) {
            	    printFoo.run();
                    i++;
                    permitFoo = false;
            	} else {
                    Thread.yield();
                }
            }finally {
            	lock.unlock();
            }
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {
        for (int i = 0; i < n; ) {
            lock.lock();
            try {
            	if(!permitFoo) {
            	    printBar.run();
            	    i++;
            	    permitFoo = true;
            	} else {
                    Thread.yield();
                }
            }finally {
            	lock.unlock();
            }
        }
    }
}

法3：无锁

class FooBar {
    private int n;

    public FooBar(int n) {
        this.n = n;
    }

    volatile boolean permitFoo = true;

    public void foo(Runnable printFoo) throws InterruptedException {     
        for (int i = 0; i < n; ) {
            if(permitFoo) {
        	printFoo.run();
            	i++;
            	permitFoo = false;
            }
            Thread.sleep(1);
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {       
        for (int i = 0; i < n; ) {
            if(!permitFoo) {
        	printBar.run();
        	i++;
        	permitFoo = true;
            }
            Thread.sleep(1);
        }
    }
}

法4：CyclicBarrier

class FooBar {
    private int n;

    public FooBar(int n) {
        this.n = n;
    }

    CyclicBarrier cb = new CyclicBarrier(2);
    volatile boolean fin = true;

    public void foo(Runnable printFoo) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            while(!fin);
            printFoo.run();
            fin = false;
            try {
		cb.await();
	    } catch (BrokenBarrierException e) {
	    }
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            try {
		cb.await();
	    } catch (BrokenBarrierException e) {
	    }
            printBar.run();
            fin = true;
        }
    }
}

3.打印零与奇偶数

1116.打印零与奇偶数
法1：Semaphore

class ZeroEvenOdd {
    private int n;
    
    public ZeroEvenOdd(int n) {
        this.n = n;
    }

    Semaphore z = new Semaphore(1);
    Semaphore e = new Semaphore(0);
    Semaphore o = new Semaphore(0);
	
    public void zero(IntConsumer printNumber) throws InterruptedException {
        for(int i=0; i<n;i++) {
        	z.acquire();
        	printNumber.accept(0);
        	if((i&1)==0) {
        		o.release();
        	}else {
        		e.release();
        	}
        }
    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        for(int i=2; i<=n; i+=2) {
        	e.acquire();
        	printNumber.accept(i);
        	z.release();
        }
    }

    public void odd(IntConsumer printNumber) throws InterruptedException {
        for(int i=1; i<=n; i+=2) {
        	o.acquire();
        	printNumber.accept(i);
        	z.release();
        }
    }
}

法2：Lock

class ZeroEvenOdd {
    private int n;
    
    public ZeroEvenOdd(int n) {
        this.n = n;
    }

    Lock lock = new ReentrantLock();
    Condition z = lock.newCondition();
    Condition num = lock.newCondition();
    volatile boolean zTurn = true;
    volatile int zIndex = 0;
	
    public void zero(IntConsumer printNumber) throws InterruptedException {
        for(;zIndex<n;) {
            lock.lock();
            try {
        	while(!zTurn) {
        		z.await();
        	}
        	printNumber.accept(0);
        	zTurn = false;
        	num.signalAll();
                zIndex++;
            }finally {
        	lock.unlock();
            }
        }
    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        for(int i=2; i<=n; i+=2) {
            lock.lock();
            try {
        	while(zTurn || (zIndex&1)==1) {
        		num.await();
        	}
        	printNumber.accept(i);
        	zTurn = true;
        	z.signal();
            }finally {
        	lock.unlock();
            }
        }
    }

    public void odd(IntConsumer printNumber) throws InterruptedException {
        for(int i=1; i<=n; i+=2) {
            lock.lock();
            try {
        	while(zTurn || (zIndex&1)==0) {
        		num.await();
        	}
        	printNumber.accept(i);
        	zTurn = true;
        	z.signal();
            }finally {
        	lock.unlock();
            }
        }
    }
}

法3：无锁

class ZeroEvenOdd {
    private int n;
    
    public ZeroEvenOdd(int n) {
        this.n = n;
    }

    volatile int stage = 0;
	
    public void zero(IntConsumer printNumber) throws InterruptedException {
        for(int i=0;i<n;i++) {
        	while(stage>0) {
                Thread.yield();
            }
    		printNumber.accept(0);
    		if((i&1)==0) {
    			stage = 1;
    		}else {
    			stage = 2;
    		}
        }
    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        for(int i=2; i<=n; i+=2) {
        	while(stage!=2) {
                Thread.yield();
            }
    		printNumber.accept(i);
    		stage = 0;
        }
    }

    public void odd(IntConsumer printNumber) throws InterruptedException {
        for(int i=1; i<=n; i+=2) {
        	while(stage!=1) {
                Thread.yield();
            }
    		printNumber.accept(i);
    		stage = 0;
        }
    }
}

4.H2O生成

1117.H2O生成
在这里插入图片描述
在这里插入图片描述
法1：Semaphore
h每获取一次释放一个o许可，o每次获取两个许可（即2次h后执行一次o）

class H2O {

    public H2O() {

    }
        Semaphore h = new Semaphore(2);
        Semaphore o = new Semaphore(0);  
    public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
	    h.acquire();
        // releaseHydrogen.run() outputs "H". Do not change or remove this line.
        releaseHydrogen.run();
        o.release();
    }

    public void oxygen(Runnable releaseOxygen) throws InterruptedException {
        o.acquire(2);
        // releaseOxygen.run() outputs "O". Do not change or remove this line.
		releaseOxygen.run();
        h.release(2);
    }
}

法2：

class H2O {

    public H2O() {

    }
        Lock lock = new ReentrantLock();
        Condition cd = lock.newCondition();
        volatile int index = 0; 
    public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
        lock.lock();
        try {
            while (index == 2)
                cd.await();
            index++;
            // releaseHydrogen.run() outputs "H". Do not change or remove this line.
            releaseHydrogen.run();
            cd.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void oxygen(Runnable releaseOxygen) throws InterruptedException {
        lock.lock();
        try {
            while (index < 2)
                cd.await();
            // releaseOxygen.run() outputs "O". Do not change or remove this line.
		    releaseOxygen.run();
            index = 0;
            cd.signalAll();
        } finally {
            lock.unlock();
        }
    }
}

5.交替打印字符串

1195.交替打印字符串

法1：信号量

class FizzBuzz {
    private int n;

    public FizzBuzz(int n) {
        this.n = n;
    }

    Semaphore f = new Semaphore(0);
    Semaphore b = new Semaphore(0);
    Semaphore fb = new Semaphore(0);
    Semaphore num = new Semaphore(1);

    // printFizz.run() outputs "fizz".
    public void fizz(Runnable printFizz) throws InterruptedException {
        for (int i = 3; i <= n; i += 3) {
            if (i % 5 != 0) {
                f.acquire();
                printFizz.run();
                num.release();
            }
        }
    }

    // printBuzz.run() outputs "buzz".
    public void buzz(Runnable printBuzz) throws InterruptedException {
        for (int i = 5; i <= n; i += 5) {
            if (i % 3 != 0) {
                b.acquire();
                printBuzz.run();
                num.release();
            }
        }
    }

    // printFizzBuzz.run() outputs "fizzbuzz".
    public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException {
        for (int i = 15; i <= n; i += 15) {
            fb.acquire();
            printFizzBuzz.run();
            num.release();
        }
    }

    // printNumber.accept(x) outputs "x", where x is an integer.
    public void number(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            num.acquire();
            // printNumber.accept(i);
            if (i % 3 == 0 && i % 5 == 0) {
                fb.release();
            } else if (i % 3 == 0 && i % 5 != 0) {
                f.release();
            } else if (i % 3 != 0 && i % 5 == 0) {
                b.release();
            } else {
                printNumber.accept(i);
                num.release();
            }
        }
    }
}

法2：管程模型

class FizzBuzz {
    private int n;

    public FizzBuzz(int n) {
        this.n = n;
    }

    Lock lock = new ReentrantLock();
    Condition cond = lock.newCondition();
    volatile int state = -1;

    // printFizz.run() outputs "fizz".
    public void fizz(Runnable printFizz) throws InterruptedException {
        for (int i = 3; i <= n; i += 3) {
            if (i % 5 == 0)
                continue;
            lock.lock();
            try {
                while (state != 3) 
                    cond.await();
                printFizz.run();
                state = -1;
                cond.signalAll();
            } finally {
                lock.unlock();
            }
        }
    }

    // printBuzz.run() outputs "buzz".
    public void buzz(Runnable printBuzz) throws InterruptedException {
        for (int i = 5; i <= n; i += 5) {
            if (i % 3 == 0)
                continue;
            lock.lock();
            try {
                while (state != 5) 
                    cond.await();
                printBuzz.run();
                state = -1;
                cond.signalAll();
            } finally {
                lock.unlock();
            }
        }
    }

    // printFizzBuzz.run() outputs "fizzbuzz".
    public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException {
        for (int i = 15; i <= n; i += 15) {
            lock.lock();
            try {
                while (state != 15) 
                    cond.await();
                printFizzBuzz.run();
                state = -1;
                cond.signalAll();
            } finally {
                lock.unlock();
            }
        }
    }

    // printNumber.accept(x) outputs "x", where x is an integer.
    public void number(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            lock.lock();
            try {
                while (state != -1)
                    cond.await();
                if (i % 15 == 0) {
                    state = 15;
                } else if (i % 3 == 0) {
                    state = 3;
                } else if (i % 5 == 0) {
                    state = 5;
                } else {
                    printNumber.accept(i);
                    // state = -1;
                }
                cond.signalAll();         
            } finally {
                lock.unlock();
            }
        }
    }
}

当然也可以有多个condition对象，这个就不写了，复制一下别人的：

private ReentrantLock lock = new ReentrantLock();
private Condition fCond = lock.newCondition();
private Condition bCond = lock.newCondition();
private Condition fbCond = lock.newCondition();
private Condition nCond = lock.newCondition();
private volatile Boolean state = false;

/**
 * use lock
 * @param printFizz
 * @throws InterruptedException
 */
// printFizz.run() outputs "fizz".
public void fizz1(Runnable printFizz) throws InterruptedException {
    for (int i = 3; i <= n; i = i + 3) {
        lock.lock();
        try {
            if (i % 5 != 0) {
                while (!state) {
                    fCond.await();
                }
                printFizz.run();
                state = false;
                nCond.signal();
            }
        }finally {
            lock.unlock();
        }
    }
}

// printBuzz.run() outputs "buzz".
public void buzz1(Runnable printBuzz) throws InterruptedException {
    for (int i = 5; i <= n; i = i + 5) {
        lock.lock();
        try {
            if (i % 3 != 0) {
                while (!state) {
                    bCond.await();
                }
                printBuzz.run();
                state = false;
                nCond.signal();
            }
        }finally {
            lock.unlock();
        }
    }
}

// printFizzBuzz.run() outputs "fizzbuzz".
public void fizzbuzz1(Runnable printFizzBuzz) throws InterruptedException {
    for (int i = 15; i <= n; i = i + 15) {
        lock.lock();
        try {
            while (!state) {
                fbCond.await();
            }
            printFizzBuzz.run();
            state = false;
            nCond.signal();
        }finally {
            lock.unlock();
        }

    }
}

// printNumber.accept(x) outputs "x", where x is an integer.
public void number1(IntConsumer printNumber) throws InterruptedException {
    for (int i = 1; i <= n; i++) {
        lock.lock();
        try {
            while (state) {
                nCond.await();
            }
            if (i % 3 == 0 && i % 5 == 0) {
                fbCond.signal();
                state = true;
            }else if (i % 3 == 0) {
                fCond.signal();
                state = true;
            }else if (i % 5 == 0) {
                bCond.signal();
                state = true;
            }else {
                printNumber.accept(i);
                nCond.signal();
            }
        }finally {
            lock.unlock();
        }
    }
}

作者：guessmyname
链接：https://leetcode-cn.com/problems/fizz-buzz-multithreaded/solution/javashi-xian-shi-yong-semaphore-huo-zhe-reentrantl/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

法3：无锁
我喜欢这种方案，简洁明了。

class FizzBuzz {
    private int n;
    private volatile int state = -1;

    public FizzBuzz(int n) {
        this.n = n;
    }

    public void fizz(Runnable printFizz) throws InterruptedException {
        for (int i = 3; i <= n; i += 3) {   
            if (i % 5 == 0)    
                continue;
            while (state != 3) {
                Thread.yield();
            }
            printFizz.run();
            state = -1;    
        }
    }

    public void buzz(Runnable printBuzz) throws InterruptedException {
        for (int i = 5; i <= n; i += 5) {   
            if (i % 3 == 0)    
                continue;
            while (state != 5) {
                Thread.yield();
            }
            printBuzz.run();
            state = -1;    //控制权交还给number()方法
        }
    }

    public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException {
        for (int i = 15; i <= n; i += 15) {   //只输出15的倍数
            while (state != 15) {
                Thread.yield();
            }

            printFizzBuzz.run();
            state = -1;    //控制权交还给number()方法
        }
    }

    public void number(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; ++i) {
            while (state != -1) {
                Thread.yield();
            }
            if (i % 15 == 0)
                state = 15;  
            else if (i % 5 == 0)
                state = 5;
            else if (i % 3 == 0)
                state = 3;
            else 
                printNumber.accept(i);
        }
    }
}

6.哲学家进餐

1226.哲学家进餐
在这里插入图片描述
在这里插入图片描述

  • 信号量模型与管程模型是线程间协作的两大利器，大部分情况下，二者可以互相转换。它们的区别在于，信号量模型可以让多个线程共享临界区，而管程模型是让线程独占临界区；
  • CountDownLatch主要用于一个线程等待多个线程的场景，而CyclicBarrier则用于多个线程之间互相等待的场景。

参考资料：https://zhuanlan.zhihu.com/p/81626432

liszlove
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode多线程题目汇总
weixin_44137260的博客
05-11 473
1114. 按序打印 多种解法，都是多线程常用工具 volite： class Foo { private volatile int flag=-1; // private AtomicInteger firstJobDone = new AtomicInteger(0); public Foo() {} public void first(Runnable printFirst) throws InterruptedException { // pr
java 多线程刷题(LeetCode-1114. 按序打印)
越看越喜欢啊
11-17 830
java多线程,volatile关键字
LeetCode_多线程
sc179的博客
08-20 384
目录哲学家进餐1 题目描述2 解题（Java）交替打印字符串1 题目描述2 解题（Java）H2O 生成1 题目描述2 解题（Java）打印零与奇偶数1 题目描述2 解题（Java）交替打印FooBar1 题目描述2 解题（Java）按序打印1 题目描述2 解题（Java）2.1 解法1：共享变量2.2 解法2：信号量 哲学家进餐 1 题目描述 5 个沉默寡言的哲学家围坐在圆桌前，每人面前一盘意面。叉子放在哲学家之间的桌面上。（5 个哲学家，5 根叉子） 所有的哲学家都只会在思考和进餐两种行为间交替。哲学家
LeetCode（多线程）- 题集
牧码的博客
01-13 600
LeetCode（多线程）- 解题集 # 题名 难度 解题 企业 1114 按序打印 简单 查看解题 爱奇艺、微软 ……
leetcode刷题多线程之打印零与奇数偶数
leileii的博客
10-16 565
使用Semaphore() import threading class ZeroEvenOdd: def __init__(self, n): self.n = n self.l1 = threading.Semaphore(1) self.l2 = threading.Semaphore(0) self.l3 = thr...
多线程leetcode-leetcode-go:leetcode-go
06-30
多线程leetcode leetcode-go # 标题 解决方案 选项 困难 标签 0001 二和 2 简单的 hashmap 0002 两个数字相加 2 中等的 singlylinkedlist ， recursion 0003 无重复字符的最长子串 中等的 0004 两个有序数组的中位数...
leetcode题目分类
12-10
这份文档列出了leetcode几乎所有题目（大约134题）的分类以及难度指示，是刷leetcode的必备良品。现在leetcode总的题目数已经达到150题，所以有部分题目没有包含在这个文档中，但是——足够了。po主刷leetcode的时候...
leetcode题目精选
03-15
leetcode题目精选，JAVA算法刷题，算法题leetcode题目精选，JAVA算法刷题，算法题leetcode题目精选，JAVA算法刷题，算法题leetcode题目精选，JAVA算法刷题，算法题leetcode题目精选，JAVA算法刷题，算法题leetcode...
多线程leetcode-leetcode:leetcode
06-30
多线程leetcode Leetcode 解决方案 Java 这是 leetcode 的个人之旅。 解决方案主要是在 Java 中。 细绳 不 问题 等级 解决方案 520 简单的 1221 简单的 345 简单的 344 简单的 804 简单的 1436 简单的 859 简单的 ...
多线程leetcode-LeetCode:某物
06-30
多线程leetcode 力码 算法 分布式文件系统 _230_KthSmallestElementinaBST _1448_CountGoodNodesInBinaryTree_DFS 快速排序 _973_KClosestPointstoOrigin_QuickSort_PQ 拓扑排序 _210_CourseSchedule2_BFS_DFS_...
Leetcode多线程题库练习（新功能尝鲜）& 个人感悟
weixin_30872499的博客
07-18 203
大家好， 我是方子龙。很久没有自己写文章了。 一面是因为工作上的需求开发任务比较重，下班回家基本上就躺床玩几把王者，度过闲暇时光。 二面是一有点时间就自己主动地去看书和学习，知道自己还缺少很多知识，由于还在进行中，输出还很少。 最近在看的书籍： 《颠覆平庸》彭小六 推荐理由：一个由程序员转写作的大佬，主要包含个人，团队，项目，时间管理。很贴近我们程序员的思维，提升个人职场竞争力。读完收益匪浅。 《...
leetcode多线程合集
princeteng's blogs
10-04 372
1114. 按序打印 与1116题类似，使用condition_variable. class Foo { public: Foo() { } mutex mtx; atomic<int> g{1}; condition_variable cv; void first(function<void()> printFirst) { unique_lock<mutex> lck(mtx);
LeetCode 多线程
zlb_zlb的博客
08-19 164
做多线程编程题，要根据n大小，顺序打印"010203.....0n"，过程中遇到了函数引用、typing数据类型。以题目为具体代码在这里做个记录。typing的用法python文档，多线程python文档 函数引用：将函数传入线程中，如下，将 printNumber传入三个子线程中。t_zero绑定到 z对象的zero方法，传入参数args=(printNumber,))，其中printNumber的类型为'Callable[[int], None]'，此类型表示传入参数是一个函数，该函数参数类型为...
[Leetcode] 多线程
chinanfsk的博客
08-29 618
前言 Java 多线程解题常用方法 & 工具类 类型 方法 说明 synchronized Object.wait(), Object.notify(), Object.notifyAll() 每一个用 synchronized 修饰的部分都是一个临界区，同一时间只允许一个线程访问 Lock Lock.lock(), Lock.unlock() 具体实现类：Reentr...
LeetCode刷题笔记【多线程】
qq_43313035
07-21 396
文章目录交替打印FooBar打印零与奇偶数按序打印H2O 生成 交替打印FooBar 题目描述： 我们提供一个类： class FooBar { public void foo() { for (int i = 0; i < n; i++) { print("foo"); } } public void bar() { for (int i =...
leetcode 多线程编程
qq_40123329的博客
08-22 595
C++多线程学习博客推荐 1 C++11多线程编程----初识 2 c++11多线程编程(二)——理解线程类的构造函数 3 c++11多线程编程(三)——竞争条件与互斥锁 4 c++11多线程编程(四)——死锁(Dead Lock) 5 c++11多线程编程(五)——unique_lock 6 c++11多线程编程(六)——条件变量(Conditio...
LeetCode-多线程-1114
chenshuang的博客
07-22 157
1114转载自： https://blog.csdn.net/fuxuemingzhu/article/details/95889253
Leetcode多线程
量子孤岛
08-12 331
1114. 按序打印 原题链接 class Foo { public: Foo() { m2.lock(); m3.lock(); } void first(function<void()> printFirst) { printFirst(); m2.unlock(); ...
LeetCode-1117. H2O 生成（多线程）
2.wa
02-03 440
Leetcode 题目描述 现在有两种线程，氢 oxygen 和氧 hydrogen，你的目标是组织这两种线程来产生水分子。 存在一个屏障（barrier）使得每个线程必须等候直到一个完整水分子能够被产生出来。 氢和氧线程会被分别给予 releaseHydrogen 和 releaseOxygen 方法来允许它们突破屏障。 这些线程应该三三成组突破屏障并能立即组合产生一个水分子。 你必须保证产生一...
sort vector<vector<int>>
最新发布
09-05
<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [vector＜string＞和vector＜int＞]...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值