进程和线程包含关系详解

1:多线程      
           (1)多线程
                A:进程：正在运行的程序，代表的是应用程序在内存中的执行区域。
                B:线程：线程是进行的执行单元，执行路径。
                C:任何一个应用程序，都至少有一条执行路径。
                D:单线程程序：应用程序只有一条执行路径。
                E:多线程程序：应用程序有多条执行路径。
               
                举例:360图形用户管理界面，迅雷下载，请人吃饭...
        (2)jvm启动的时候，是单线程的还是多线程的？
                是多线程的。
                假如jvm的启动时单线程的，那么，在程序的运行过程中，就可能存在着
                内存溢出的隐患。不可能等到内存溢出了，在去进行垃圾回收。所以，jvm
                启动是多线程的。至少有两个，主线程和垃圾回收线程。
        (3)java中实现多线程的方式
                A:继承Thread类
                        步骤：
                        **自定义类继承Thread类
                        **重写run方法
                        **创建自定义类的对象
                        **调用start方法
                        
                        代码体现：
                        
                        public class ThreadDemo extends Thread
                        {
                                public void run()
                                {
                                        //code
                                }
                        }

                        public class ThreadDemoTest
                        {
                                public static void main(String[] args)
                                {
                                        ThreadDemo td1 = new ThreadDemo();        
                                        ThreadDemo td2 = new ThreadDemo();

                                        td1.start();
                                        td2.start();
                                }
                        }

                B:实现Runnable接口
                        步骤：
                        **创建自定义类实现Runnable接口
                        **在自定义类中实现Runnable接口中的run方法
                        **创建自定义类对象，并把该对象作为参数传递给
                          Thread类的构造方法来创建Thread的对象
                        **调用start方法
                        
                        代码体现：

                        public class RunnableDemo implements Runnable
                        {
                                public void run()
                                {
                                        //code
                                }
                        }

                        public class RunnableDemoTest
                        {
                                public static void main(String[] args)
                                {
                                        RunnableDemo rd = new RunnableDemo();

                                        Thread t1 = new Thread(rd);
                                        Thread t2 = new Thread(rd);

                                        t1.start();
                                        t2.start();
                                }
                        }
        (4)Thread类中的常用的几个小方法
                A:String getName():获取线程的名称
                B:static Thread currentThread():获取当前线程的对象的引用
                        用于不是Thread类的子类获取线程对象的名称。
                        格式：Thread.currentThread().getName();
                C:void setName(String name):通过set方法设置线程对象的名称。
                D:Thread(String name):通过构造方法设置线程对象的名称。
        (5)线程的随机性原理
                CPU的特点：在同一时刻，只能有一个线程执行。
                所以，多个线程其实是在抢占CPU的资源。而CPU呢，却是在这些线程中做着高速的切换。
        (6)线程的生命周期和在生命周期中各个状态的特点
                新建：当一个线程对象被创建，但是没有开启，这个时候，只是对象线程对象开辟了
                      内存空间和初始化数据。
                就绪：新建的对象调用start方法，就到了就绪状态。
                      在这个状态的线程对象，具有执行资格，没有执行权。
                运行：当线程对象获取到了CPU的资源。
                      在这个状态的线程对象，具有执行资格，也具有执行权。
               
                      阻塞：运行过程中的线程由于某些原因(比如wait,sleep)，释放了执行权和执行资格。
                            当然，他们可以回到运行状态。只不过，不是直接回到。
                            而是先回到就绪状态。
                死亡：当线程对象调用的run方法结束，或者直接调用stop方法，就让线程对象死亡，
                      在内存中变成了垃圾。
                 
2:线程同步
        (1)产生线程安全的原因
                A:多个线程访问出现延迟。
                B:线程访问的随机性

                注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。
        (2)如果判断一个线程程序有没有安全问题呢？
                A:多个线程操作共享数据
                B:这个操作是分多条语句执行的。
        (3)解决线程安全问题的方式
                A:同步代码块
                B:格式:
                        synchronized(对象)
                        {
                                //需要被同步的代码
                        }
        (4)同步代码块问题：
                A:同步代码块的锁是任意同一对象。
                B:当你发现你把某个程序加了同步后，还没有解决线程安全问题。
                  这个时候，你需要考虑你使用的是否是同一把锁(对象);

这两者的区别：
       一个进程中存在1个或多个的线程，线程包含于进程里边   
       你启动的Java程序是一个进程(JVM)
           在这个JVM里面运行着包含你创建的一些线程
举个例子：
进程是像是光缆　线程是光缆里面的光纤

概念该说的上面都说完了，给你举个例，
打开你的计算机任务管理器，那里面有好多进程，那是CPU分配的，



例如迅雷下载，双击启动thunder.exe迅雷程序，cpu会给它分配一个资源，即进程，这个进程里面可以包含多个线程，
你可以下载多个电影等，，，

进程有独立的地址空间，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，所以多进程的程序要比多线程的程序健壮，  一个进程开始时至少会有一个主线程 。

进程和线程的关系：
（1）一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。
（2）资源分配给进程，同一进程的所有线程共享该进程的所有资源。
（3）线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。
（4）处理机分给线程，即真正在处理机上运行的是线程。
（5）线程是指进程内的一个执行单元，也是进程内的可调度实体。
线程与进程的区别：
（1）调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位。
（2）并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行。
（3）拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。
（4）系统开销：在创建或撤销进程的时候，由于系统都要为之分配和回收资源，导致系统的明显大于创建或撤销线程时的开销。但进程有独立的地址空间，进程崩溃后，在保护模式下不会对其他的进程产生影响，而线程只是一个进程中的不同的执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但是在进程切换时，耗费的资源较大，效率要差些。

说的简单点，操作系统是一个城市，进程是一个公司，线程是公司里的人。
一个城市可以有N个公司，一个公司可以有N个人。
但公司是不能做事情的，事情要由人来做。
所以，进程只是一个概念，一个范围，用来标记和归类的，线程才是真正办事的。
这样是不是好理解点？

恩。。。谢谢，清晰多了

进程就是一个运行中的程序。
一个进程中可以有多个线程，线程是CPU调度和分派的基本单位。我们可以理解为线程就是程序运行中的一条路径。
允许多个线程并发执行，提高程序运行效率。
例如：迅雷多线程下载，QQ多个人同时聊天。

吕书凯 发表于 2012-9-5 22:49
进程和线程的主要差别在于它们是不同的操作系统资源管理方式。

进程有独立的地址空间，一个进程崩溃后，在 ...

"但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉"

线程在一个进程里是有属于自己的地址空间的,一个线程死掉,该线程所在的进程并不会死掉,只有这个进程中的所有线程都死掉(或都说都执行结束),那么这个进程才会跟着结束.