Windows下用c++创建进程,再创建两个线程

Posted 2023-05-01

在Windows下用c++编写程序,创建一个进程,包含三个线程,第一个线程执行1到100的求和,第二个执行10的阶乘计算,另一个负责将第一个和第二个线程的结果进行输出!

详细注释,源代码,还有方法说明!

参考技术A 我写的代码，没编译，你试试行不行
DWORD WINAPI SumThread(LPVOID lp)//求和线程

int* sum=(int*)lp;
for(int i=1;i<101;i++)


(*sum)+=i;


return 0;//线程返回

DWORD WINAPI MulThread(LPVOID lp)//求阶乘线程

int* mul=(int*)lp;
for(int i=1;i<11;i++)


(*mul)*=i;

return 0;

DWORD WINAPI PrintThread(LPVOID lp)//打印线程


HANDLE handle ;

int sum=0 ;

int mul=1;

handle = CreateThread(NULL,NULL,SumThread,(LPVOID)&sum,NULL,NULL);//创建求和线程

CloseHandle(handle);//关闭线程句柄

handle = CreateThread(NULL,NULL,MulThread,(LPVOID)&mul,NULL,NULL);//创建求阶乘线程

CloseHandle(handle);//关闭线程句柄

printf("%d",sum);//打印和

printf("%d",mul);//打印阶乘

return 0;

void main()


HANDLE handle;

handle = CreateThread(NULL,NULL,PrintThread,NULL,NULL,NULL);

CloseHandle(handle);
参考技术B 说法一：进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.

线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行

说法二：进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于：

简而言之,一个程序至少有一个进程,一个进程至少有一个线程.

线程的划分尺度小于进程，使得多线程程序的并发性高。

另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

说法三：多线程共存于应用程序中是现代操作系统中的基本特征和重要标志。用过UNIX操作系统的读者知道进程，在UNIX操作系统中，每个应用程序的执行都在操作系统内核中登记一个进程标志，操作系统根据分配的标志对应用程序的执行进行调度和系统资源分配，但进程和线程有什么区别呢？

进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于：

线程的划分尺度小于进程，使得多线程程序的并发性搞。

另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

进程（Process）是最初定义在Unix等多用户、多任务操作系统环境下用于表示应用程序在内存环境中基本执行单元的概念。以Unix操作系统为例，进程是Unix操作系统环境中的基本成分、是系统资源分配的基本单位。Unix操作系统中完成的几乎所有用户管理和资源分配等工作都是通过操作系统对应用程序进程的控制来实现的。

C、C++、Java等语言编写的源程序经相应的编译器编译成可执行文件后，提交给计算机处理器运行。这时，处在可执行状态中的应用程序称为进程。从用户角度来看，进程是应用程序的一个执行过程。从操作系统核心角度来看，进程代表的是操作系统分配的内存、CPU时间片等资源的基本单位，是为正在运行的程序提供的运行环境。进程与应用程序的区别在于应用程序作为一个静态文件存储在计算机系统的硬盘等存储空间中，而进程则是处于动态条件下由操作系统维护的系统资源管理实体。多任务环境下应用程序进程的主要特点包括：

●进程在执行过程中有内存单元的初始入口点，并且进程存活过程中始终拥有独立的内存地址空间；

●进程的生存期状态包括创建、就绪、运行、阻塞和死亡等类型；

●从应用程序进程在执行过程中向CPU发出的运行指令形式不同，可以将进程的状态分为用户态和核心态。处于用户态下的进程执行的是应用程序指令、处于核心态下的应用程序进程执行的是操作系统指令。

在Unix操作系统启动过程中，系统自动创建swapper、init等系统进程，用于管理内存资源以及对用户进程进行调度等。在Unix环境下无论是由操作系统创建的进程还要由应用程序执行创建的进程，均拥有唯一的进程标识（PID）。

说法四：应用程序在执行过程中存在一个内存空间的初始入口点地址、一个程序执行过程中的代码执行序列以及用于标识进程结束的内存出口点地址，在进程执行过程中的每一时间点均有唯一的处理器指令与内存单元地址相对应。

Java语言中定义的线程（Thread）同样包括一个内存入口点地址、一个出口点地址以及能够顺序执行的代码序列。但是进程与线程的重要区别在于线程不能够单独执行，它必须运行在处于活动状态的应用程序进程中，因此可以定义线程是程序内部的具有并发性的顺序代码流。

Unix操作系统和Microsoft Windows操作系统支持多用户、多进程的并发执行，而Java语言支持应用程序进程内部的多个执行线程的并发执行。多线程的意义在于一个应用程序的多个逻辑单元可以并发地执行。但是多线程并不意味着多个用户进程在执行，操作系统也不把每个线程作为独立的进程来分配独立的系统资源。进程可以创建其子进程，子进程与父进程拥有不同的可执行代码和数据内存空间。而在用于代表应用程序的进程中多个线程共享数据内存空间，但保持每个线程拥有独立的执行堆栈和程序执行上下文（Context）。

基于上述区别，线程也可以称为轻型进程 (Light Weight Process，LWP)。不同线程间允许任务协作和数据交换，使得在计算机系统资源消耗等方面非常廉价。

线程需要操作系统的支持，不是所有类型的计算机都支持多线程应用程序。Java程序设计语言将线程支持与语言运行环境结合在一起，提供了多任务并发执行的能力。这就好比一个人在处理家务的过程中，将衣服放到洗衣机中自动洗涤后将大米放在电饭锅里，然后开始做菜。等菜做好了，饭熟了同时衣服也洗好了。

需要注意的是：在应用程序中使用多线程不会增加 CPU 的数据处理能力。只有在多CPU 的计算机或者在网络计算体系结构下，将Java程序划分为多个并发执行线程后，同时启动多个线程运行，使不同的线程运行在基于不同处理器的Java虚拟机中，才能提高应用程序的执行效率。

创建进程和线程

1、在 Windows 操作系统中创建进程

　　在 windows 操作系统中，我们创建一个进程通常就是打开某个应用软件，这便在电脑中创建了一个进程。更原始一点的，我们在命令提示符中来做（我们以打开记事本这个进程为例）：

　　第一步：windows+R,输入cmd,打开 cmd 命令提示符

　　　　　　

　　第二步：在命令提示符中输入 notepad,按 Enter 键便会弹出记事本应用软件

　　　　　　

 

 PS：常用的windows 应用软件命令

　　　　1、regedit：打开注册表编辑器

　　　　2、control：打开控制面板

　　　　3、msconfig：打开系统配置

　　　　4、gpedit.msc：打开本地组策略

　　　　5、explorer：打开资源管理器

　　　　6、taskmgr：任务管理器

　　　　7、logoff：直接注销计算机

　　　　8、osk：打开屏幕键盘

　　　　9、calc：打开计算器

　　　　10、mspaint：调出画图软件

　　　　11、dxdiag：查看电脑详细配置信息

　　　　12、mstsc：打开远程桌面连接

　　　　13、systeminfo：查看计算机基本信息

　　　　14、notepad：打开记事本

回到顶部

2、在 Java 中创建进程

第一种方法：通过 Runtime 类的 exec() 方法来创建进程

1 2 3 4 5

public class Runtime extends Object ①、表示当前进程所在的虚拟机实例，每个Java应用程序都有一个Runtime类的Runtime ，允许应用程序与运行应用程序的环境进行接口。 ②、由于任何进程只会运行与一个虚拟机实例当中，即只会产生一个虚拟机实例（底层源码采用 单例模式） ③、当前运行时可以从getRuntime方法获得。

　　 

 

　　由上面源码可以看到，构造器私有化了，即外部我们不能 new 一个新的 Runtime 实例，而内部给了我们一个获取 Runtime 实例的方法 getRuntime() 。

 

通过 Runtime 类创建一个 记事本的 进程

1 2 3 4 5 6 7 8 9

public class ProcessTest {           public static void main(String[] args) throws Exception {         Runtime run = Runtime.getRuntime();         //打开记事本         run.exec("notepad");     }   }

　　

第二种方法：通过 ProcessBuilder 创建线程

1 2 3

public final class ProcessBuilder extends Object<br>①、此类用于创建操作系统进程。 ②、每个ProcessBuilder实例管理进程属性的集合。 start()方法使用这些属性创建一个新的Process实例。 start()方法可以从同一实例重复调用，以创建具有相同或相关属性的新子进程。

1 2 3 4 5 6 7 8 9

public class ProcessTest {           public static void main(String[] args) throws Exception {         //打开记事本         ProcessBuilder pBuilder = new ProcessBuilder("notepad");         pBuilder.start();     }   }

回到顶部

3、在 Java 中创建线程

第一种方法：继承 Thread 类

1 2 3

public class Thread extends Object implements Runnable

 

步骤：1、定义一个线程类 A 继承于 java.lang.Thread 类

　　　2、在 A 类中覆盖 Thread 类的 run() 方法

　　　3、在 run() 方法中编写需要执行的操作

　　　4、在 main 方法（线程）中，创建线程对象，并启动线程

　　　　　　创建线程类：A类 a = new A()类；

　　　　　　调用 start() 方法启动线程：a.start();

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

package com.ys.thread;   class Thread1 extends Thread{     @Override     public void run() {         for(int i = 0 ; i < 10 ;i++){             System.out.println("播放音乐"+i);         }     } }   public class ThreadTest {     public static void main(String[] args) {         for(int i = 0 ; i < 10 ; i++){             System.out.println("玩游戏"+i);             if(i==5){                 Thread1 th1 = new Thread1();                 th1.start();             }         }     }   }

　　结果：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

玩游戏0 玩游戏1 玩游戏2 玩游戏3 玩游戏4 玩游戏5 玩游戏6 玩游戏7 玩游戏8 玩游戏9 播放音乐0 播放音乐1 播放音乐2 播放音乐3 播放音乐4 播放音乐5 播放音乐6 播放音乐7 播放音乐8 播放音乐9

　　注意：我们看结果，并不是出现 5 个先打游戏，然后在播放音乐，这是线程调度的结果，两个线程同时在争抢 CPU 的资源，即最后的结果，前面5个打游戏的必然先出现的，后面的啥时候出现播放音乐就看 CPU 怎么调度了，这是随机的。我们不能干涉。

 

第二种方法：实现 Runnable 接口

1 2	@FunctionalInterface public interface Runnable

　　

1、Runnable接口应由任何类实现，其实例将由线程执行。 该类必须定义一个无参数的方法，称为run 。 
2、该接口旨在为希望在活动时执行代码的对象提供一个通用协议。此类整个只有一个 run() 抽象方法

 

步骤：1、定义一个线程类 A 实现于 java.lang.Runnable 接口（注意：A类不是线程类,没有 start()方法，不能直接 new A 的实例启动线程）

　　　2、在 A 类中覆盖 Runnable 接口的 run() 方法

　　　3、在 run() 方法中编写需要执行的操作

　　　4、在 main 方法（线程）中，创建线程对象，并启动线程

　　　　　　创建线程类：Thread t = new Thread( new A类() ) ；

　　　　　　调用 start() 方法启动线程：t.start();

 

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

class Runnable1 implements Runnable{     @Override     public void run() {         for(int i = 0 ; i < 10 ;i++){             System.out.println("播放音乐"+i);         }     } }   public class RunnableTest {     public static void main(String[] args) {         for(int i = 0 ; i < 10 ; i++){             System.out.println("玩游戏"+i);             if(i==5){                 Thread th1 = new Thread(new Runnable1());                 th1.start();             }         }     }   }

　　

 

 第三种方法：使用匿名内部类创建线程

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public static void main(String[] args) {         for(int i = 0 ; i < 10 ; i++){             System.out.println("玩游戏"+i);             if(i==5){                 new Thread(new Runnable() {                     @Override                     public void run() {                         for(int i = 0 ; i < 10 ;i++){                             System.out.println("播放音乐"+i);                         }                     }                 }).start();             }         }     }

　　

注意：

1、启动线程是调用 start() 方法，而不是 调用 run() 方法。

　　解析：run()方法:在本线程内调用run()方法，和其他方法没有什么区别，可以重复多次调用；

　　　　　start()方法:启动一个线程，实际上还是调用该Runnable对象的run()方法。

　　　　　打开 Thread 类的源码，start()方法里面有一句：

　　　　　　　　private native void start0();  //native 关键字：本地程序调用　　　　

　　　　native关键字指的是Java本地接口调用，即是使用Java调用本地操作系统的函数功能完成一些特殊的操作，而这样的代码开发在Java中几乎很少出现，因为Java的最大特点是可移植性，如果一个程序 只能在固定的操作系统上使用，那么可移植性就将彻底丧失，多线程的实现一定需要操作系统的支持，那么start0()方法实际上就和抽象方法很类似，没有方法体，而是交给JVM 去实现，即在windows下的JVM可能使用A方法实现start0()，在linux下的JVM可能使用B方法实现start0()，在调用时并不会关心具体是何方式实现了start0()方法，只会关心最终的操作结果，交给 JVM去匹配了不同的操作系统。

 

2、不能多次启动同一个线程，即多次调用 start() 方法，只能调用一次，否则报错：