用解释程序交错执行2个线程

已于 2024-07-08 00:44:05 修改
阅读量244 收藏 2
点赞数 2
文章标签： 数据结构 多任务 解释程序 多线程 操作系统
于 2024-07-07 19:54:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaasssdddd96/article/details/140250765
版权

多线程问题，对初学者来说，会常常感到神秘。特别想知道它里面到底是怎么执行的；遇到问题时，又会觉得十分迷惑。

前面的例子，swap 语句串扰执行问题，实现了一个assign指令的解释器。现在就借用它的代码，用解释程序演示一下多线程是怎么执行的。

现在注意力集中到考虑，以swap(a,b):, swap(a,c):, 为蓝本的2个线程，每个线程各执行相应的swap代码10次。线程的数据结构是：

struct thread_proc {
        int ecount;
        int count;
        struct assign **ins;
        int n;
        int cur;
};

其中，用ecount表示thread的任务是执行10次，count从 0计数，到ecount执行结束。ins照旧，存放swap(a,b):或swap(a,c):的指令。n是指令的长度。cur是thread当前执行到的位置。

线程初始化为各执行swap(a,b):或swap(a,c):10次：

struct assign *swap_ab_ins[3]= {
        &all_assigns[0], &all_assigns[1], &all_assigns[2]
};
struct assign *swap_ac_ins[3]= {
        &all_assigns[3], &all_assigns[4], &all_assigns[5]
};
struct thread_proc thread2[2]=
{
        {10, 0, swap_ab_ins, 3, 0},
        {10, 0, swap_ac_ins, 3, 0},
};

线程执行，每个片断执行1~3个线程指令：

void execute(struct thread_proc *t, int n)
{
        int i;
        int pos;
        struct assign **a;
        a = t->ins;
        if(t==&thread2[0]) {
                printf("swap(a,b):");
        }
        else {
                printf("swap(a,c):");
        }

        for(i=0; i<n; i++) {
                if(i) printf("\t");
                pos = t->cur;
                print_ins_nl(a[pos], 0);
                *(a[pos]->left) = *(a[pos]->right);
                printf("\t");
                print_vars(&result); printf("\n");
                t->cur++;
                if(t->cur>=t->n) {
                        t->count++;
                        t->cur=0;
                }
                if(finish(t)) break;
        }
}

调度程序，选择"下一个"需要执行的线程，交错执行每个线程：

struct thread_proc *run;
int finish(struct thread_proc *t)
{
        return t->count>=t->ecount;
}

int sched()
{
        struct thread_proc *next;
        if(run== &thread2[0]) {
                next= &thread2[1];
        } else {
                next= &thread2[0];
        }
        if(!finish(next)) {
                run= next;
        }
        if(!finish(run)) return 1;
        return 0;
}

当sched()选择的"下一个"线程已经finish，sched()就返回0。执行就结束了。就这些了。完整的代码贴上：

#include <stdio.h>

struct vars {
        int a;
        int b;
        int c;
        int t1;
        int t2;
};

struct vars init= {'A', 'B', 'C', 'x', 'z'};
struct vars result;

struct assign {
        int *left;
        int *right;
};

struct assign all_assigns[] = {
        {&result.t1,&result.a}, {&result.a, &result.b}, {&result.b,&result.t1},
        {&result.t2,&result.a}, {&result.a, &result.c}, {&result.c,&result.t2},
};


void print_ins_nl(struct assign *a, int nl)
{
        int i;
        int *pi= a->left;
        printf("\t(%d)\t", a- &all_assigns[0]);
        for(i=0; i<2; i++) {
                if(pi==&result.a) printf("a"); else
                if(pi==&result.b) printf("b"); else
                if(pi==&result.c) printf("c"); else
                if(pi==&result.t1) printf("t1"); else
                if(pi==&result.t2) printf("t2");
                if(pi==a->left) {
                        printf("=");
                        pi=a->right;
                }
        }
        if(nl)
        printf(";\n");
        else
        printf(";");
}

void print_ins(struct assign *a)
{
        print_ins_nl(a, 1);
}


void print_vars(struct vars *var)
{
        printf("(%c, %c, %c, :%c, :%c)", var->a, var->b,var->c, var->t1, var->t2
);
}


struct thread_proc {
        int ecount;
        int count;
        struct assign **ins;
        int n;
        int cur;
};

struct assign *swap_ab_ins[3]= {
        &all_assigns[0], &all_assigns[1], &all_assigns[2]
};
struct assign *swap_ac_ins[3]= {
        &all_assigns[3], &all_assigns[4], &all_assigns[5]
};
struct thread_proc thread2[2]=
{
        {10, 0, swap_ab_ins, 3, 0},
        {10, 0, swap_ac_ins, 3, 0},
};

struct thread_proc *run;
int finish(struct thread_proc *t)
{
        return t->count>=t->ecount;
}

int sched()
{
        struct thread_proc *next;
        if(run== &thread2[0]) {
                next= &thread2[1];
        } else {
                next= &thread2[0];
        }
        if(!finish(next)) {
                run= next;
        }
        if(!finish(run)) return 1;
        return 0;
}

void execute(struct thread_proc *t, int n)
{
        int i;
        int pos;
        struct assign **a;
        a = t->ins;
        if(t==&thread2[0]) {
                printf("swap(a,b):");
        }
        else {
                printf("swap(a,c):");
        }

        for(i=0; i<n; i++) {
                if(i) printf("\t");
                pos = t->cur;
                print_ins_nl(a[pos], 0);
                *(a[pos]->left) = *(a[pos]->right);
                printf("\t");
                print_vars(&result); printf("\n");
                t->cur++;
                if(t->cur>=t->n) {
                        t->count++;
                        t->cur=0;
                }
                if(finish(t)) break;
        }
}

extern "C" int rand();
int random()
{
        return rand()%3+1;
}

int main()
{
        int i;
        printf("swap(a, b):\n");
        for(i=0; i<3; i++) {
                print_ins(&all_assigns[i]);
        }
        printf("swap(a, c):\n");
        for(i=0; i<3; i++) {
                print_ins(&all_assigns[i+3]);
        }
        printf("[execute]:\n");
        result = init;
        run = &thread2[0];
        do {
                execute(run, random());
        }
        while(sched());
        return 0;
}

运行结果是交错执行2个线程的效果：

swap(a, b):
        (0)     t1=a;
        (1)     a=b;
        (2)     b=t1;
swap(a, c):
        (3)     t2=a;
        (4)     a=c;
        (5)     c=t2;
[execute]:
swap(a,b):      (0)     t1=a;   (A, B, C, :A, :z)
swap(a,c):      (3)     t2=a;   (A, B, C, :A, :A)
                (4)     a=c;    (C, B, C, :A, :A)
                (5)     c=t2;   (C, B, A, :A, :A)
swap(a,b):      (1)     a=b;    (B, B, A, :A, :A)
swap(a,c):      (3)     t2=a;   (B, B, A, :A, :B)
                (4)     a=c;    (A, B, A, :A, :B)
                (5)     c=t2;   (A, B, B, :A, :B)
swap(a,b):      (2)     b=t1;   (A, A, B, :A, :B)
                (0)     t1=a;   (A, A, B, :A, :B)
                (1)     a=b;    (A, A, B, :A, :B)
swap(a,c):      (3)     t2=a;   (A, A, B, :A, :A)
swap(a,b):      (2)     b=t1;   (A, A, B, :A, :A)
swap(a,c):      (4)     a=c;    (B, A, B, :A, :A)
                (5)     c=t2;   (B, A, A, :A, :A)
swap(a,b):      (0)     t1=a;   (B, A, A, :B, :A)
swap(a,c):      (3)     t2=a;   (B, A, A, :B, :B)
                (4)     a=c;    (A, A, A, :B, :B)
                (5)     c=t2;   (A, A, B, :B, :B)
swap(a,b):      (1)     a=b;    (A, A, B, :B, :B)
                (2)     b=t1;   (A, B, B, :B, :B)
swap(a,c):      (3)     t2=a;   (A, B, B, :B, :A)
swap(a,b):      (0)     t1=a;   (A, B, B, :A, :A)
                (1)     a=b;    (B, B, B, :A, :A)
                (2)     b=t1;   (B, A, B, :A, :A)
swap(a,c):      (4)     a=c;    (B, A, B, :A, :A)
swap(a,b):      (0)     t1=a;   (B, A, B, :B, :A)
                (1)     a=b;    (A, A, B, :B, :A)
                (2)     b=t1;   (A, B, B, :B, :A)
swap(a,c):      (5)     c=t2;   (A, B, A, :B, :A)
swap(a,b):      (0)     t1=a;   (A, B, A, :A, :A)
                (1)     a=b;    (B, B, A, :A, :A)
                (2)     b=t1;   (B, A, A, :A, :A)
swap(a,c):      (3)     t2=a;   (B, A, A, :A, :B)
swap(a,b):      (0)     t1=a;   (B, A, A, :B, :B)
swap(a,c):      (4)     a=c;    (A, A, A, :B, :B)
                (5)     c=t2;   (A, A, B, :B, :B)
                (3)     t2=a;   (A, A, B, :B, :A)
swap(a,b):      (1)     a=b;    (A, A, B, :B, :A)
                (2)     b=t1;   (A, B, B, :B, :A)
                (0)     t1=a;   (A, B, B, :A, :A)
swap(a,c):      (4)     a=c;    (B, B, B, :A, :A)
                (5)     c=t2;   (B, B, A, :A, :A)
swap(a,b):      (1)     a=b;    (B, B, A, :A, :A)
                (2)     b=t1;   (B, A, A, :A, :A)
                (0)     t1=a;   (B, A, A, :B, :A)
swap(a,c):      (3)     t2=a;   (B, A, A, :B, :B)
                (4)     a=c;    (A, A, A, :B, :B)
                (5)     c=t2;   (A, A, B, :B, :B)
swap(a,b):      (1)     a=b;    (A, A, B, :B, :B)
                (2)     b=t1;   (A, B, B, :B, :B)
                (0)     t1=a;   (A, B, B, :A, :B)
swap(a,c):      (3)     t2=a;   (A, B, B, :A, :A)
                (4)     a=c;    (B, B, B, :A, :A)
swap(a,b):      (1)     a=b;    (B, B, B, :A, :A)
                (2)     b=t1;   (B, A, B, :A, :A)
swap(a,c):      (5)     c=t2;   (B, A, A, :A, :A)
swap(a,c):      (3)     t2=a;   (B, A, A, :A, :B)
swap(a,c):      (4)     a=c;    (A, A, A, :A, :B)
swap(a,c):      (5)     c=t2;   (A, A, B, :A, :B)

如果带互斥锁。互斥锁是处理器硬件和操作系统休眠/调度程序相互作用的特殊代码。解释程序中可用setjmp/longjmp来模拟。如果线程请求互斥锁遇到已加锁，须退出本次执行，回到sched转让处理机。带锁的程序修改之后如下：

#include <stdio.h>
#include <setjmp.h>

struct vars {
        int a;
        int b;
        int c;
        int t1;
        int t2;
};

struct vars init= {'A', 'B', 'C', 'x', 'z'};
struct vars result;

struct assign {
        int *left;
        int *right;
};

struct assign all_assigns[] = {
        {&result.t1,&result.a}, {&result.a, &result.b}, {&result.b,&result.t1},
        {&result.t2,&result.a}, {&result.a, &result.c}, {&result.c,&result.t2},
};


void print_ins_nl(struct assign *a, int nl)
{
        int i;
        int *pi= a->left;
        printf("\t(%d)\t", a- &all_assigns[0]);
        for(i=0; i<2; i++) {
                if(pi==&result.a) printf("a"); else
                if(pi==&result.b) printf("b"); else
                if(pi==&result.c) printf("c"); else
                if(pi==&result.t1) printf("t1"); else
                if(pi==&result.t2) printf("t2");
                if(pi==a->left) {
                        printf("=");
                        pi=a->right;
                }
        }
        if(nl)
        printf(";\n");
        else
        printf(";");
}

void print_ins(struct assign *a)
{
        print_ins_nl(a, 1);
}


void print_vars(struct vars *var)
{
        printf("(%c, %c, %c, :%c, :%c)", var->a, var->b,var->c, var->t1, var->t2
);
}


struct thread_proc {
        int ecount;
        int count;
        struct assign **ins;
        int n;
        int cur;
};

struct assign *swap_ab_ins[3]= {
        &all_assigns[0], &all_assigns[1], &all_assigns[2]
};
struct assign *swap_ac_ins[3]= {
        &all_assigns[3], &all_assigns[4], &all_assigns[5]
};
struct thread_proc thread2[2]=
{
        {10, 0, swap_ab_ins, 3, 0},
        {10, 0, swap_ac_ins, 3, 0},
};

struct thread_proc *run;
int finish(struct thread_proc *t)
{
        return t->count>=t->ecount;
}

int sched()
{
        struct thread_proc *next;
        if(run== &thread2[0]) {
                next= &thread2[1];
        } else {
                next= &thread2[0];
        }
        if(!finish(next)) {
                run= next;
        }
        if(!finish(run)) return 1;
        return 0;
}

jmp_buf resched;
struct mutex {
        int stat;
} mutex;
void lock() {
        if(mutex.stat==0) {
                mutex.stat=1;
                return;
        }
        longjmp(resched, 1);
}
void unlock() { mutex.stat=0; }

void execute(struct thread_proc *t, int n)
{
        int i;
        int pos;
        struct assign **a;
        a = t->ins;
        if(t==&thread2[0]) {
                printf("swap(a,b):");
        }
        else {
                printf("swap(a,c):");
        }

        for(i=0; i<n; i++) {
                if(i) printf("\t");
                pos = t->cur;
				if(pos==0) {
				        lock();
				}
                print_ins_nl(a[pos], 0);
                *(a[pos]->left) = *(a[pos]->right);
                printf("\t");
                print_vars(&result); printf("\n");
                t->cur++;
                if(t->cur>=t->n) {
						unlock();
                        t->count++;
                        t->cur=0;
                }
                if(finish(t)) break;
        }
}

extern "C" int rand();
int random()
{
        return rand()%3+1;
}

int main()
{
        int i;
        printf("swap(a, b):\n");
        for(i=0; i<3; i++) {
                print_ins(&all_assigns[i]);
        }
        printf("swap(a, c):\n");
        for(i=0; i<3; i++) {
                print_ins(&all_assigns[i+3]);
        }
        printf("[execute]:\n");
        result = init;
        run = &thread2[0];
		if(setjmp(resched)!=0) goto resched;
        do {
                execute(run, random());
                resched: ;
        }
        while(sched());
        return 0;
}

运行结果：

swap(a, b):
        (0)     t1=a;
        (1)     a=b;
        (2)     b=t1;
swap(a, c):
        (3)     t2=a;
        (4)     a=c;
        (5)     c=t2;
[execute]:
swap(a,b):      (0)     t1=a;   (A, B, C, :A, :z)
swap(a,c):swap(a,b):    (1)     a=b;    (B, B, C, :A, :z)
swap(a,c):swap(a,b):    (2)     b=t1;   (B, A, C, :A, :z)
                (0)     t1=a;   (B, A, C, :B, :z)
                (1)     a=b;    (A, A, C, :B, :z)
swap(a,c):swap(a,b):    (2)     b=t1;   (A, B, C, :B, :z)
swap(a,c):      (3)     t2=a;   (A, B, C, :B, :A)
                (4)     a=c;    (C, B, C, :B, :A)
swap(a,b):swap(a,c):    (5)     c=t2;   (C, B, A, :B, :A)
                (3)     t2=a;   (C, B, A, :B, :C)
                (4)     a=c;    (A, B, A, :B, :C)
swap(a,b):swap(a,c):    (5)     c=t2;   (A, B, C, :B, :C)
swap(a,b):      (0)     t1=a;   (A, B, C, :A, :C)
                (1)     a=b;    (B, B, C, :A, :C)
                (2)     b=t1;   (B, A, C, :A, :C)
swap(a,c):      (3)     t2=a;   (B, A, C, :A, :B)
swap(a,b):swap(a,c):    (4)     a=c;    (C, A, C, :A, :B)
swap(a,b):swap(a,c):    (5)     c=t2;   (C, A, B, :A, :B)
swap(a,b):      (0)     t1=a;   (C, A, B, :C, :B)
swap(a,c):swap(a,b):    (1)     a=b;    (A, A, B, :C, :B)
                (2)     b=t1;   (A, C, B, :C, :B)
                (0)     t1=a;   (A, C, B, :A, :B)
swap(a,c):swap(a,b):    (1)     a=b;    (C, C, B, :A, :B)
                (2)     b=t1;   (C, A, B, :A, :B)
                (0)     t1=a;   (C, A, B, :C, :B)
swap(a,c):swap(a,b):    (1)     a=b;    (A, A, B, :C, :B)
                (2)     b=t1;   (A, C, B, :C, :B)
                (0)     t1=a;   (A, C, B, :A, :B)
swap(a,c):swap(a,b):    (1)     a=b;    (C, C, B, :A, :B)
                (2)     b=t1;   (C, A, B, :A, :B)
swap(a,c):      (3)     t2=a;   (C, A, B, :A, :C)
swap(a,b):swap(a,c):    (4)     a=c;    (B, A, B, :A, :C)
swap(a,b):swap(a,c):    (5)     c=t2;   (B, A, C, :A, :C)
swap(a,b):      (0)     t1=a;   (B, A, C, :B, :C)
                (1)     a=b;    (A, A, C, :B, :C)
                (2)     b=t1;   (A, B, C, :B, :C)
swap(a,c):      (3)     t2=a;   (A, B, C, :B, :A)
                (4)     a=c;    (C, B, C, :B, :A)
swap(a,b):swap(a,c):    (5)     c=t2;   (C, B, A, :B, :A)
swap(a,b):      (0)     t1=a;   (C, B, A, :C, :A)
                (1)     a=b;    (B, B, A, :C, :A)
                (2)     b=t1;   (B, C, A, :C, :A)
swap(a,c):      (3)     t2=a;   (B, C, A, :C, :B)
                (4)     a=c;    (A, C, A, :C, :B)
                (5)     c=t2;   (A, C, B, :C, :B)
swap(a,b):      (0)     t1=a;   (A, C, B, :A, :B)
                (1)     a=b;    (C, C, B, :A, :B)
                (2)     b=t1;   (C, A, B, :A, :B)
swap(a,c):      (3)     t2=a;   (C, A, B, :A, :C)
                (4)     a=c;    (B, A, B, :A, :C)
swap(a,c):      (5)     c=t2;   (B, A, C, :A, :C)
                (3)     t2=a;   (B, A, C, :A, :B)
                (4)     a=c;    (C, A, C, :A, :B)
swap(a,c):      (5)     c=t2;   (C, A, B, :A, :B)
swap(a,c):      (3)     t2=a;   (C, A, B, :A, :C)
swap(a,c):      (4)     a=c;    (B, A, B, :A, :C)
swap(a,c):      (5)     c=t2;   (B, A, C, :A, :C)
swap(a,c):      (3)     t2=a;   (B, A, C, :A, :B)
                (4)     a=c;    (C, A, C, :A, :B)
swap(a,c):      (5)     c=t2;   (C, A, B, :A, :B)

加锁之后，swap(a,b)和swap(a,c)串行执行。数据得到了保护。

aaasssdddd96
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c语言线程启动,C++程序中启动线程的方法
weixin_35980267的博客
05-22 1420
C++11 引入一个全新的线程库，包含启动和管理线程的工具，提供了同步(互斥、锁和原子变量)的方法，我将试图为你介绍这个全新的线程库。如果你要编译本文中的代码，你至少需要一个支持 C++11 的编译器，我使用的是 GCC 4.6.1，需要使用 -c++0x 或者 -c++11 参数来启用 C++11 的支持。启动线程在 C++11 中启动一个线程是非常简单的，你可以使用 std:thread 来创...
进程/线程调度程序
sunflower_up_plus的博客
09-05 1098
调度 调度简介 当有两个或多个进程通过处于就绪态时，CPU需要选择执行的进程。完成该工作的称为调度程序，调度程序所使用的算法称为调度算法。 进程的行为 I/O活动指进程因等待外部设备（如磁盘）完成工作而阻塞。 计算密集型指进程将大部分cpu时间花在计算上，而I/O密集型指等待I/O上花费了大量的时间。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fuWFyPU1-1630470696910)(./picture/IO与计算交替出现.png)] I/O密集型的进程会花费大部分
如何确保三个线程顺序执行
weixin_30349597的博客
10-30 253
场景：有三个线程t1、t2、t3。确保三个线程t1执行完后t2执行，t2执行完成后t3执行。 1、thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B publicclassThreadTest1{ //T1、T2、T3三个线程顺序执行 public...
java线程交替执行的实现
北尘
12-02 1190
这是个老生常谈的问题了，但里面涵盖的知识还是有必要好好琢磨一下子。这里简单总结了一下； 方式1：使用synchronized+wait/notify实现 @Slf4j public class ThreadDemo3 { public static void main(String[] args) { RunnableImpl runnable = new RunnableImpl(100,1); String [] threadNames = new S..
Java 多线程中两个线程交替执行，一个输出偶数，一个输出奇数
YHY的日常
08-30 502
1、sync class ThreadPrintDemo2 { public static void main(String[] args) { final ThreadPrintDemo2 demo2 = new ThreadPrintDemo2(); Thread t1 = new Thread(demo2::print1); Thread t2 = new Thread(demo2::print2); t1.start(); t2.start(); }
c++ 多线程_如何调试多线程程序
weixin_39872893的博客
11-07 1019
当然，多线程调试的前提是你需要熟悉多线程的基础知识，包括线程的创建和退出、线程之间的各种同步原语等。如果您还不熟悉多线程编程的内容，可以参考这个专栏《C++ 多线程编程专栏》，如果您不熟悉 gdb 调试可以参考这个专栏《Linux GDB 调试教程》。一、调试多线程的方法使用 gdb 将程序跑起来，然后按 Ctrl + C 将程序中断下来，使用 info threads 命令查看当前进程有多少线程...
【Java 多线程】多线程带来的的风险-线程安全、多线程五个经典案例
热门推荐
1226
04-01 1万+
日常开发中如果用到多线程编程，也一定会涉及到线程安全问题 线程安全这个问题就不太好理解 正因为如此，程序猿们才尝试发明出更多的编程模型来处理并发编程的任务 例如：多进程、多线程、actor、csp、async+await、定时器+回调 操作系统，调度线程的时候，是随机的 (抢占式执行) 正式因为这样的随机性，就可能导致程序的执行出现一些 bug 如果因为这样的调度随机性引入了 bug，就认为代码是线程不安全的，如果是因为这样的调度随机性，也没有带来 bug，就认为代码是线程安全的 这里的线程安全指的是有.
08 线程按序交替执行案例
朱古力的博客
05-11 131
线程按序交替执行案例 要求： 编写一个程序，开启 3 个线程，这三个线程的 ID 分别为 A、B、C，每个线程将自己的 ID 在屏幕上打印 10 遍，要求输出的结果必须按顺序显示。 如：ABCABCABC…… 依次递归 代码实现： 使用 Lock 锁 使用 Condition 控制线程通信 import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.co
程序 进程 线程 并发 并行
SKPrimin的博客
11-04 3540
程序 进程 线程 并发 并行 程序(program) : 是为完成特定任务、用某种语言编写的一组指令的集合,是一段静态的代码（程序是静态的） 进程(process) : 是操作系统对一个正在运行的程序的一种抽象。在一个系统上可以同时运行多个进程，而每个进程都好像在独占地使用硬件。是程序的一次执行过程，正在运行的一个程序，进程作为资源分配的单位，在内存中会为每个进程分配不同的内存区域， 是一个动的过程 （进程是动态的） 进程的生命周期 : 有它自身的产生、存在和消亡的过程。 线程(th
Java多线程超详细讲解（看这个就够了）
weixin_59330273的博客
06-19 353
进程与线程 进程是程序的一次动态执行过程，它需要经历从代码加载，代码执行到执行完毕的一个完整的过程，这个过程也是进程本身从产生，发展到最终消亡的过程。多进程操作系统能同时达运行多个进程（程序），由于 CPU 具备分时机制，所以每个进程都能循环获得自己的CPU 时间片。由于 CPU 执行速度非常快，使得所有程序好像是在同时运行一样。 多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。线程是比进程更小的执行单位，线程是进程的基础之上进行进一步的划分。所谓多线程是指一个进程.
三个线程交错输出
11-14
在计算机科学中，多线程是并发执行任务的一种方式，特别是在...5. 理解和实践线程交错执行的策略。 通过深入学习和实践这个实验，开发者可以更好地理解和掌握多线程编程，为编写高效、安全的并发程序打下坚实的基础。
C++11用两个线程轮流打印整数的实现方法
12-16
在`main()`函数中，我们创建了两个线程`t1`和`t2`，分别执行`printeven()`和`printodd()`，最后使用`join()`等待两个线程执行完毕，确保程序不会提前结束。 总结一下，这个程序展示了C++11线程的基本操作，包括线程...
改变 Python 中线程执行顺序的方法
09-24
这是因为线程调度是由操作系统决定的，可能会出现线程交错执行的情况。下面的代码展示了这个现象： ```python import threading import time class MyThread(threading.Thread): def run(self): for i in range...
Python测试线程应用程序过程解析
09-18
线程是Python中实现多任务的一种方式，允许程序同时执行多个任务，从而提升效率。在编写线程应用程序时，测试是确保其正确性和稳定性的关键步骤。 测试的重要性在于保证软件的质量、客户满意度、减少新功能的影响、...
SignalsAndSlots:使用多个执行程序执行SignalsSlots
05-16
该信号/插槽库与其他库之间的主要区别在于，它提供了指定所使用执行程序类型的方法。 ＃＃目录 延迟同步 异步 股线 线程池 去做 局限性 ＃＃特征 简单的信号和插槽机制 可指定的执行程序（同步，同步延迟，异步，...
数据结构第14节 加权图
hummhumm的专栏
07-07 1331
( V ) 是顶点的集合。( E ) 是边的集合，每条边连接 ( V ) 中的一对顶点。( W ) 是一个函数，将每条边映射到一个实数上，即 ( W: E \rightarrow \mathbb{R} )。
6、Redis系统-数据结构-03-压缩列表
qq_29434541的博客
07-07 2398
由于压缩列表需要进行空间扩展操作，这就需要重新分配内存，因此连锁更新一旦发生，会导致压缩列表占用的内存空间多次重新分配，直接影响到压缩列表的访问性能。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。而当新插入的元素较大时，可能会导致后续元素的。
【数据结构】线性表----栈详解
最新发布
Skrrapper的博客
07-08 1207
栈（Stack）是一种常见的数据结构，它具有**后进先出（Last In, First Out, LIFO）**的特点。栈的运作类似于物理世界中的叠盘子：最新放上去的盘子最先被拿走，而最底部的盘子最后才能被取出。如果你先拿底下的盘子，那么就有可能出现整个盘子组全部倒塌碎落一地——这也就是所谓的栈出错。栈有着的特点。所以它的出栈和入栈也遵循着这个特点。我们在存取元素的时候，一般是在进行——也就是所谓的盘子顶；而另一端称为，一般就是数据结构的头结点。入栈出栈的顺序只需记住：顺序必须有规律，例如。
数据结构--单链表实现
LH__1314的博客
07-05 1465
链表和顺序表都是线性表的一种，但是顺序表在物理结构和逻辑结构上都是连续的，但链表在逻辑结构上是连续的，而在物理结构上不一定连续；来看以下图片来认识链表与顺序表的差别这里以动态顺序表为例，和链表中的单链表对比一下动态顺序表单链表这里就可以很清晰的看到顺序表的底层其实就是一个数组，数据的是连续存储的（顺序表物理结构连续）；而链表它每一个数据都不是连续的（链表物理结构上不一定连续）。链表节点通过观察上图，我们会发现链表每一个节点都存放在数据和下一个节点的地址。
两个原子操作交错执行
05-31
您好！这是一个经典的并发编程问题，也被称为“临界区问题”。在并发程序中，当多个线程访问共享资源时，如果没有正确地进行同步，就会发生数据竞争或死锁等问题。而临界区问题就是指多个线程同时访问同一个共享资源，而且这些线程之间的操作是互相独立的，因此这些操作可能会交错执行，导致程序出现错误。 一个经典的例子是两个线程同时对一个变量进行加1操作，代码如下： ``` int count = 0; // 线程1 count++; // 线程2 count++; ``` 如果这两个操作没有被正确地同步，那么就可能出现下面的情况： 1. 线程1读取count的值为0； 2. 线程2读取count的值为0； 3. 线程1执行count++，将count的值变为1； 4. 线程2执行count++，将count的值再次变为1，而不是2； 这种情况就是两个原子操作交错执行的典型例子。为了避免这种情况，我们可以使用互斥锁、信号量等机制来保证临界区的互斥访问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值