#name "main"
#include "stdlib.h"
#runtime thread 8

//线程1的函数
export void thread1()
{
  while(1)
  {
    print("I'm thread 1");
     sleep(1000);
  }
}

//线程2的函数
export void thread2()
{
   while(1)
  {
    print("I'm thread 2");
     sleep(1000);
  }
}

//线程3的函数
export void thread3()
{
   while(1)
  {
    print("I'm thread 3");
     sleep(1000);
  }
}

//主线程
export int main()
{
  CreateThread("thread1");//开始线程1
  CreateThread("thread2");//开始线程2
  CreateThread("thread3");//开始线程3
  while(1) sleep(1000);
  return 0;
}

# centos
yum install criu
# ubuntu
apt-get install criu

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/mount.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/param.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <signal.h>
#include <sched.h>

#define STACK_SIZE	(8 * 4096)

static int ac;
static char **av;
static int ns_exec(void *_arg)
{
        close(0);
	setsid();
	execvp(av[1], av + 1);
	return 1;
}

int main(int argc, char **argv)
{
	void *stack;
	pid_t pid;

	ac = argc;
	av = argv;

	stack = mmap(NULL, STACK_SIZE, PROT_WRITE | PROT_READ,
    MAP_PRIVATE | MAP_GROWSDOWN | MAP_ANONYMOUS, -1, 0);
	clone(ns_exec, stack + STACK_SIZE,
			CLONE_NEWPID | CLONE_NEWIPC | SIGCHLD, NULL);
	return 0;
}

gcc -o newns newns.c

#!/bin/sh
while :; do
    sleep 1
    date
done

[root@VM-8-5-centos thread]# ./newns bash test.sh
[root@VM-8-5-centos thread]# 2021年 07月 06日 星期二 19:55:53 CST
2021年 07月 06日 星期二 19:55:54 CST
2021年 07月 06日 星期二 19:55:55 CST
2021年 07月 06日 星期二 19:55:56 CST
2021年 07月 06日 星期二 19:55:57 CST

ps -ef| grep 'bash test.sh'  | head -1 | awk '{print $2}' | xargs -I PID criu dump -t PID --shell-job  --images-dir /home/thread/checkpoint

[root@VM-8-5-centos thread]# cd checkpoint/
[root@VM-8-5-centos checkpoint]# ls
core-14.img   fdinfo-3.img  fs-24.img   inventory.img    mm-24.img       pages-1.img  stats-dump
core-1.img    files.img     ids-14.img  ipcns-var-9.img  pagemap-14.img  pages-2.img  tty-info.img
core-24.img   fs-14.img     ids-1.img   mm-14.img        pagemap-1.img   pstree.img
fdinfo-2.img  fs-1.img      ids-24.img  mm-1.img         pagemap-24.img  seccomp.img
[root@VM-8-5-centos checkpoint]# criu restore --images-dir /home/thread/checkpoint --shell-job &
[1] 17235
[root@VM-8-5-centos checkpoint]# 
2021年 07月 06日 星期二 19:56:26 CST
2021年 07月 06日 星期二 19:56:27 CST
2021年 07月 06日 星期二 19:56:28 CST
2021年 07月 06日 星期二 19:56:29 CST
2021年 07月 06日 星期二 19:56:30 CST

[root@VM-8-5-centos thread]# crit decode -i /home/thread/checkpoint/core-1.img --pretty >> /home/thread/checkpoint/core-1.json

On Mon, 5 Aug 1996, Peter P. Eiserloh wrote:
> 
> We need to keep a clear the concept of threads.  Too many people
> seem to confuse a thread with a process.  The following discussion
> does not reflect the current state of linux, but rather is an
> attempt to stay at a high level discussion.

NO!

There is NO reason to think that "threads" and "processes" are separate
entities. That's how it's traditionally done, but I personally think it's a
major mistake to think that way. The only reason to think that way is
historical baggage. 

Both threads and processes are really just one thing: a "context of
execution".  Trying to artificially distinguish different cases is just
self-limiting. 

A "context of execution", hereby called COE, is just the conglomerate of 
all the state of that COE. That state includes things like CPU state 
(registers etc), MMU state (page mappings), permission state (uid, gid) 
and various "communication states" (open files, signal handlers etc).

Traditionally, the difference between a "thread" and a "process" has been
mainly that a threads has CPU state (+ possibly some other minimal state),
while all the other context comes from the process. However, that's just
_one_ way of dividing up the total state of the COE, and there is nothing
that says that it's the right way to do it. Limiting yourself to that kind of
image is just plain stupid. 

The way Linux thinks about this (and the way I want things to work) is that
there _is_ no such thing as a "process" or a "thread". There is only the
totality of the COE (called "task" by Linux). Different COE's can share parts
of their context with each other, and one _subset_ of that sharing is the
traditional "thread"/"process" setup, but that should really be seen as ONLY
a subset (it's an important subset, but that importance comes not from
design, but from standards: we obviusly want to run standards-conforming
threads programs on top of Linux too). 

......

void give_a_fun(void (*p)(void *));

class inherit_me_show_u_sth_cool {
   public virtual void run()=0;
//other
...
}

uintptr_t _beginthread( // NATIVE CODE
   void( __cdecl *start_address )( void * ),
   unsigned stack_size,
   void *arglist
);
uintptr_t _beginthread( // MANAGED CODE
   void( __clrcall *start_address )( void * ),
   unsigned stack_size,
   void *arglist
);
uintptr_t _beginthreadex( // NATIVE CODE
   void *security,
   unsigned stack_size,
   unsigned ( __stdcall *start_address )( void * ),
   void *arglist,
   unsigned initflag,
   unsigned *thrdaddr
);
uintptr_t _beginthreadex( // MANAGED CODE
   void *security,
   unsigned stack_size,
   unsigned ( __clrcall *start_address )( void * ),
   void *arglist,
   unsigned initflag,
   unsigned *thrdaddr
);