线程创造进程

A. 进程和它创建的线程之间的关系

进程是应用程序的执抄行实例，每个进程是由私有的虚拟地址空间、代码、数据和其他各种系统资
源组成的。进程在运行过程中创建的资源随着进程的终止而被销毁，所使用的系统资源在进程终止时
被释放或关闭。
线程是进程内部的一个执行单元（如一个函数或一个活跃的类对象等）。系统创建好进程后，实
际上就启动执行了该进程的主执行线程。主执行线程终止了，进程也就随之终止。每一个进程至少有
一个线程（即主执行线程，它无需由用户去主动创建，是由系统在应用程序启动后创建的），用户根
据需要在应用程序中创建其他线程，使多个线程并发地运行在同一个进程中。一个进程中的所有线程
都在该进程的虚拟地址空间中，并使用这些虚拟地址空间、全局变量和系统资源，所以线程之间的通
讯要比进程之间的通讯容易得多。多线程设计在实际中的使用较为广泛。

B. 在一个线程中可以在创建线程或进程吗

线程可以创建线程，像Java中，main函数就是一个线程来的，可以在main中创建线程。但是，线程应该不能创建进程。因为进程比线程要宏观得多。

C. 线程和进程的关系

进程和线程的关系是包含关系,即一个进程包含一个或多个线程。但同时线程与进程是相互依存的,也就是说没有线程的进程不存在,没有进程的线程也不存在。一但进程被创建,一个线程也就被自动创建。

D. linux怎样在进程中创建线程

方法一：PS
在ps命令中，“-T”选项可以开启线程查看。下面的命令列出了由进程号为<pid>的进程创建的版所有线程权。
$ ps -T -p <pid>

“SID”栏表示线程ID，而“CMD”栏则显示了线程名称。

方法二： Top
top命令可以实时显示各个线程情况。要在top输出中开启线程查看，请调用top命令的“-H”选项，该选项会列出所有Linux线程。在top运行时，你也可以通过按“H”键将线程查看模式切换为开或关。
$ top -H

E. 点击“一个线程”按钮，创建一个线程，不断输出“启动一个进程”；

这个需要用到后台线程执行，否则一运行主线程就卡住了：
public partial class Form1 : Form
{
// 打印放在后台执行
BackgroundWorker m_Worker;

// 用一个标记来看是否请求停止执行
bool m_NeedRun = false;

public Form1()
{
InitializeComponent();

m_Worker = new BackgroundWorker();
m_Worker.DoWork += new DoWorkEventHandler(m_Worker_DoWork);
}

void m_Worker_DoWork(object sender, DoWorkEventArgs e)
{
while( m_NeedRun ) // 后台可以循环打印，不影响主线程的运行
Console.Write( "" );
}

private void button1_Click(object sender, EventArgs e)
{
m_NeedRun = true;
m_Worker.RunWorkerAsync();
}

private void button2_Click(object sender, EventArgs e)
{
m_NeedRun = false;
}
}

F. 创建进程到底比线程多多少开销

查看最大线程数：
cat /proc/sys/kernel/threads-max
ulimit

User limits - limit the use of system-wide resources.

Syntax
ulimit [-acdfHlmnpsStuv] [limit]

Options

-S Change and report the soft limit associated with a resource.
-H Change and report the hard limit associated with a resource.

-a All current limits are reported.
-c The maximum size of core files created.
-d The maximum size of a process's data segment.
-f The maximum size of files created by the shell(default option)
-l The maximum size that may be locked into memory.
-m The maximum resident set size.
-n The maximum number of open file descriptors.
-p The pipe buffer size.
-s The maximum stack size.
-t The maximum amount of cpu time in seconds.
-u The maximum number of processes available to a single user.
-v The maximum amount of virtual memory available to the process.

ulimit provides control over the resources available to the shell and to processes started by it, on systems that allow such control.

If limit is given, it is the new value of the specified resource. Otherwise, the current value of the soft limit for the specified resource is printed, unless the `-H' option is supplied.

When setting new limits, if neither `-H' nor `-S' is supplied, both the hard and soft limits are set.

Values are in 1024-byte increments, except for `-t', which is in seconds, `-p', which is in units of 512-byte blocks, and `-n' and `-u', which are unscaled values.

The return status is zero unless an invalid option is supplied, a non-numeric argument other than unlimited is supplied as a limit, or an error occurs while setting a new limit.

ulimit is a bash built in command.

G. 什么工具能禁止进程线程创建

这个不需要工具的你直接在网络搜索一下创建一个REG格式的文件写入注册表就搞定了

H. linux中的fork是创建进程还是线程

fork是创建进程，pthread是线程。

I. Java并发编程：如何创建线程，进程

在java中如果要创建线程的话，一般有两种方式：1）继承Thread类；2）实现Runnable接口。
1.继承Thread类
继承Thread类的话，必须重写run方法，在run方法中定义需要执行的任务。

123456789101112

class MyThread extends Thread{ private static int num = 0; public MyThread(){ num++; } @Override public void run() { System.out.println("主动创建的第"+num+"个线程"); }}

创建好了自己的线程类之后，就可以创建线程对象了，然后通过start()方法去启动线程。注意，不是调用run()方法启动线程，run方法中只是定义需要执行的任务，如果调用run方法，即相当于在主线程中执行run方法，跟普通的方法调用没有任何区别，此时并不会创建一个新的线程来执行定义的任务。public class Test { public static void main(String[] args) { MyThread thread = new MyThread(); thread.start(); }} class MyThread extends Thread{ private static int num = 0; public MyThread(){ num++; } @Override public void run() { System.out.println("主动创建的第"+num+"个线程"); }}

在上面代码中，通过调用start()方法，就会创建一个新的线程了。为了分清start()方法调用和run()方法调用的区别，请看下面一个例子：

212223
public class Test { public static void main(String[] args) { System.out.println("主线程ID:"+Thread.currentThread().getId()); MyThread thread1 = new MyThread("thread1"); thread1.start(); MyThread thread2 = new MyThread("thread2"); thread2.run(); }} class MyThread extends Thread{ private String name; public MyThread(String name){ this.name = name; } @Override public void run() { System.out.println("name:"+name+" 子线程ID:"+Thread.currentThread().getId()); }

J. 一个进程可以创建多少个线程

一个进程可以开启的线程受可用内存限制，如果是32位的机器，那么默认一个进程有2G的可专用内存，而属每个线程默认分析1M的栈空间，所以这种情况下理论最线程数在2000多个。一个解决办法是创建线程时减少线程栈的大小或是使用64位的系统。64位系统应该可以忽略这个问题了。当然受cpu及磁盘速度及物理内存的限制。不用到达上限值，你的机器应该已经是慢如牛车了。