C++多线程编程，有没有方法让线程内的一些连续的语句一次执行完，在跳到其它的线程？

Posted 2023-04-24

因为线程内的一些语句需要一次性执行完，有没有方法能做到这样？
比如
n++；
if（n:>100）

。。。。

以上语句需要一次性执行完，中间程序不能跳到其它的线程去执行，请问有没有这样的方法？

说实话，没用过锁不建议你这么干，用锁用不好会出问题的，
你可以用一个类似信号量的机制，一种思路。
假设有两个或者多个线程同时并发：
t1、t2、t3...........tn.....，假设t1就是那个要连续执行的线程，其他线程为t1完毕后在执行。
定义一个全局变量，可以是任意类型，就以bool 为例吧：
bool b = false，默认false
下面是关键，就是定义线程的起始方法：
f1、f2、f3..........fn......，假设f1是t1的方法

void t1()

...//这些都是执行过程
...//这些都是执行过程
b = true;//这个是方法的最后一句，通知其他线程，我已经执行完了，你们可以开始了

void t2()

while (!b)

//什么都不做，空循环，当b=true的时候，while终止

//以下才是真正的内容
....
....

void f3、f4...都与f1一致，目的就是等t1完全执行完毕后才执行他们

领悟这种思想了吗？ 参考技术A 这个可以有，在你要执行的语句前加互斥锁mutex，执行后解锁，每个线程有冲突的地方都加追问

你好，能给示例代码吗?太感谢你了

追答

关于互斥锁的使用，百度一下，有很多说明
基本步骤就是建锁，初始化，加锁，解锁

参考技术B 不知道线程同步，信号量、互斥量，还搞个pi的多线程啊

Java多线程之线程同步

一、多线程出现的安全问题：

1、问题的原因：

多个线程执行的不确定性引起执行结果的不稳定。当多条语句在操作同一个线程共享数据时，
一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误。
2、解决的办法：

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

二、Synchronized的使用方法：

 

1、操作共享数据的代码，即为需要被同步的代码。不能包含代码多或者少。
2、共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
3、同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
4、要求：多个线程必须要共用同一把锁。

三、同步机制中的锁：

1、同步锁机制：

对于并发工作，你需要某种方式来防止两个任务访问相同的资源(其实就是共享资源竞争)。
防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。
第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，
就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。

2、synchronized的锁是什么：

任意对象都可以作为同步锁。所有对象都自动含有单一的锁(监视器)。
同步方法的锁:静态方法(类名.class) 、非静态方法(this)
同步代码块:自己指定，很多时候也是指定为this或类名.class

3、注意事项：

必须确保使用同一个资源的多个线程共用一把锁，
这个非常重要，否则就无法保证共享资源的安全。
一个线程类中的所有静态方法共用同一把锁(类名.class) ，
所有非静态方法共用同一把锁(this) ，同步代码块( 指定需谨慎)

例子：创建三个窗口卖票，总票数为100张。使用实现Runnable接口的方式
1、问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题。
2、问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
3、如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，
其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
4、在Java中，我们通过同步机制，来解决线程的安全问题。

 1 class Window implements Runnable{
 2 
 3     private int ticket = 100;
 4     @Override
 5     public void run() {
 6 
 7         while(true){
 8             synchronized (this){
 9                 //此时的this:唯一的Window1的对象   
10                 if (ticket > 0) {
11 
12                     try {
13                         Thread.sleep(100);
14                     } catch (InterruptedException e) {
15                         e.printStackTrace();
16                     }
17 
18                     System.out.println(Thread.currentThread().getName() 
19                             + ":卖票，票号为：" + ticket);
20 
21                     ticket--;
22                 } else {
23                     break;
24                 }
25             }
26         }
27     }
28 }
29 
30 
31 public class WindowTest {
32     public static void main(String[] args) {
33         Window1 w = new Window1();
34 
35         Thread t1 = new Thread(w);
36         Thread t2 = new Thread(w);
37         Thread t3 = new Thread(w);
38 
39         t1.setName("窗口1");
40         t2.setName("窗口2");
41         t3.setName("窗口3");
42 
43         t1.start();
44         t2.start();
45         t3.start();
46     }
47 }

使用同步方法解决实现Runnable接口的线程安全问题。
关于同步方法的总结：
1、同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2、非静态的同步方法，同步监视器是：this。
3、静态的同步方法，同步监视器是：当前类本身。

 1 class Window implements Runnable {
 2     private int ticket = 100;
 3     @Override
 4     public void run() {
 5         while (true) {
 6             show();
 7         }
 8     }
 9     
10     private synchronized void show(){
11         //同步监视器：this
12         //synchronized (this){
13 
14             if (ticket > 0) {
15 
16                 try {
17                     Thread.sleep(100);
18                 } catch (InterruptedException e) {
19                     e.printStackTrace();
20                 }
21 
22                 System.out.println(Thread.currentThread().getName() 
23                         + ":卖票，票号为：" + ticket);
24 
25                 ticket--;
26             }        
27     }
28 }
29 
30 
31 public class WindowTest {
32     public static void main(String[] args) {
33         Window3 w = new Window3();
34 
35         Thread t1 = new Thread(w);
36         Thread t2 = new Thread(w);
37         Thread t3 = new Thread(w);
38 
39         t1.setName("窗口1");
40         t2.setName("窗口2");
41         t3.setName("窗口3");
42 
43         t1.start();
44         t2.start();
45         t3.start();
46     }
47 }

四、线程同步的范围：

1、如何找问题，即代码是否存在线程安全 (非常重要 )
(1)明确哪些代码是多线程运行的代码。
(2)明确多个线程是否有共享数据。
(3)明确多线程运行代码中是否有多条语句操作共享数据。

2、如何解决呢 (非常重要)
对多条操作共享数据的语句，只能让一个线程都执行完，
在执行过程中，其他线程不可以参与执行。
即所有操作共享数据的这些语句都要放在同步范围中。

3、切记：
范围太小：没锁住所有有安全问题的代码
范围太大：没发挥多线程的功能。

4、释放锁的操作：
●当前线程的同步方法、同步代码块执行结束。
●当前线程在同步代码块、同步方法中遇到break、returm终 止了该代码块、该方法的继续执行。
●当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
●当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。 

5、不会释放锁的操作：
●线程执行同步代码块或同步方法时，程序调用Thread. sleep()、Thread.yield()方法暂停当前线程的执行。
●线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，
该线程不会释放锁(同步监视器)，应尽量避免使用suspend()和resume()来控制线程。

6、线程的死锁问题：
●死锁原因：
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，
就形成线程死锁。出现死锁后，不会出现异常或提示，只是所有的线程都处于阻塞状态，无法继续。
●解决方法：
专门的算法或原则、尽量减少同步资源的定义、尽量避免嵌套同步。

五、Lock(锁)：

1、从JDK 5.0开始，Java提供 了更强大的线程同步机制一通过显式定 义同
步锁对象来实现同步。同步锁使用Lock对象充当。

2、java.util.concurrent locks.Lock接口是控制多个线程对共享资源进行访问的
工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象
加锁，线程开始访问共享资源之前应先获得Lock对象。

3、Reentrantl _ock类实现了Lock ，它拥有与synchronized相同的并发性和
内存语义，在实现线程安全的控制中，比较常用的是Reentrantl _ock，可以
显式加锁、释放锁。

 

4、synchronized与Lock的对比：
(1)Lock是显式锁(手动开启和关闭锁，别忘记关闭锁)，synchronized是隐式锁， 出了作用域自动释放。
(2)Lock只有代码块锁，synchronized有 代码块锁和方法锁。
(3)使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)。
(4)优先使用顺序:Lock→同步代码块(已经进入了方法体，分配了相应资源)→同步方法(在方法体之外)。