黑马程序员技术交流社区

标题: 多线程概述 [打印本页]
作者: a80C51    时间: 2015-9-22 21:38
标题: 多线程概述
1,进程（process）
        定义：处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。

2，进程的特征：
        A：独立性，独立的实体，拥有独立的资源，拥有自己私有地址；
        B：动态性，它是正在系统中活动的指令集合，拥有自己的生命周期和不同状态；
        C：并发性，多个进程可以在单个处理器上并发执行，多个进程之间不会相互影响。

3，线程（Thread）
        1）定义：轻量级进程（Lightweight Process）是进程的执行单元。进程内的多条顺序执行流。
        2）线程也是独立的，并发的。

4，进程和线程的关系
A，        线程是进程的组成部分，一个进程可以拥有多线程，线程必有父进程；
B，        线程拥有自己的堆栈等，但不拥有系统资源。与父进程中其他线程共享拥有的全部资源。
C，        线程的执行是抢占式的，一个线程可以是创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。
D，        一个程序运行后至少有一个进程，一个进程可以包含多个进程，但至少有一个进程。

5，多线程优势
A，        进程之间不能共享内存，但线程之间共享内存非常容易；
B，        系统创建进程时，需要为该进程重新分配系统资源，但创建线程则代价小很多；
C，        Java内置多线程功能支持。

6，线程的创建和启动
A        使用继承Thread类的方法来创建线程类
1）        使用Thread类代表线程，所有线程对象都必须是Thread类或者其子类的实例。
2）        创建和启动该种多线程的步骤如下代码所示：
  1. /*
  2. * 该程序两个目的：
  3. * 目的一：了解线程创建的步骤
  4. * 目的二：通过此例子，了解线程的执行顺序
  5. */

  7. package com.wayne.MyThread;

  9. //【创建线程步骤】1st,继承Thread
  10. public class MyFirstThread extends Thread
  11. {
  12.         private int i;//创建一个标志位，用于表示程序的运行
  13.        
  14.         //【创建线程步骤】2nd,重写run()方法，形成线程执行体
  15.         public void run()
  16.         {
  17.                 for(;i<100;i++)//此处的i是成员变量i,其在new的过程中已经有初值0
  18.                 {
  19.                         //当线程类继承Thread类时，直接使用this即可获取当前线程
  20.                         System.out.println(this.getName()+" "+i);
  21.                 }
  22.         }
  23.        
  24.         //main()方法代表了主线程的线程执行体
  25.         public static void main(String[] args)
  26.         {
  27.                 //【创建线程步骤】3rd,创建Thread的子类MyFirstThread的实例，用于创建线程对象
  28.                 MyFirstThread myFirstThread1st = new MyFirstThread();
  29.                 MyFirstThread myFirstThread2nd = new MyFirstThread();
  30.                
  31.                 for(int i = 0;i<100;i++)
  32.                 {
  33.                         //Thread.currentThread()获取当前正在执行的线程对象
  34.                         //getName()返回调用该方法的线程名字
  35.                         System.out.println(Thread.currentThread().getName()+" "+i);
  36.                        
  37.                         if(i == 20)//当标志位运行到20时，创建两个线程
  38.                         {                       
  39.                                 //【创建线程步骤】4th,调用start()方法启动该线程
  40.                                 myFirstThread1st.start();
  41.                                 myFirstThread2nd.start();
  42.                                
  43.                                 //notice:直接调用线程对象的run方法，系统会认为该对象为普通对象，顺序执行下去
  44.                                 //myFirstThread1st.run();
  45.                                 //myFirstThread2nd.run();
  46.                         }
  47.                 }
  48.         }
  49. }
复制代码

3）        main()方法的方法体代表主线程的线程执行体。
4）        使用继承Thread类的方法来创建线程类时，多个线程之间无法共享线程类的实例变量。
5）        线程的两个方法
a)        Thread.currentThread():返回当前正在执行的线程对象；
b)        getName():返回调用该方法的线程名字。
B        通过实现Runnable接口创建线程类
1）        创建和启动该种多线程的步骤如下代码所示：
  1. /*
  2. * 该程序一个目的：
  3. * 目的一：了解通过实现Runnable接口来进行线程创建的步骤
  4. */

  6. package com.wayne.MyThread;

  8. //【创建线程步骤】1st,定义Runnable接口的实现类
  9. public class MyRunnableThread implements Runnable{

  11.         private int i;//创建一个标志位，用于表示程序的运行
  12.         //【创建线程步骤】2nd,重写Runnable接口的run方法，形成线程执行体
  13.         @Override
  14.         public void run() {
  15.                 for(;i<100;i++)
  16.                 {
  17.                         //当线程类实现Runnable接口时，
  18.                         //获取当前线程，只能通过Thread.currentThread()获得
  19.                         System.out.println(Thread.currentThread().getName()+" "+i);
  20.                 }
  21.                
  22.         }
  23.        
  24.         public static void main(String[] args) {
  25.        
  26.                 for(int i = 0;i<100;i++)
  27.                 {
  28.                         //Thread.currentThread()获取当前正在执行的线程对象
  29.                         //getName()返回调用该方法的线程名字
  30.                         System.out.println(Thread.currentThread().getName()+" "+i);
  31.                        
  32.                         if(i == 50)
  33.                         {
  34.                                 //【创建线程步骤】3rd,创建Runnable实现类myRunnableThread的实例
  35.                                 MyRunnableThread myRunnableThread1st = new MyRunnableThread();
  36.                                 MyRunnableThread myRunnableThread2nd = new MyRunnableThread();
  37.                                
  38.                                 //【创建线程步骤】4th,利用Runnable实现类myRunnableThread的实例，作为Thread的target，来创建Thread对象
  39.                                 //此Thread类对象才是这个线程的线程对象。
  40.                                 Thread threadRunnable1st = new Thread(myRunnableThread1st,"New 1st RunnableThread");
  41.                                 Thread threadRunnable2nd = new Thread(myRunnableThread2nd,"New 2nd RunnableThread");
  42.                                
  43.                                 //【创建线程步骤】5th,调用线程对象的start()方法启动该线程
  44.                                 threadRunnable1st.start();
  45.                                 threadRunnable2nd.start();
  46.                         }
  47.                 }
  48.         }
  49. }
复制代码

2）        采用Runnable对象只是线程的target，而多个线程共享一个target,因此，多个线程可以共享同一个线程类的实例变量。
C        通过使用Callable和Future创建线程
1）        创建和启动该种多线程和步骤如下代码所示：
  1. /*
  2. * 此程序的目的是了解通过实现Callable接口来进行线程创建的步骤
  3. */
  4. package com.wayne.MyThread;

  6. //如果通过实现Callable<Integer>来创建对象，
  7. //则需要导入如下的包java.util.concurrent.Callable
  8. import java.util.concurrent.Callable;
  9. import java.util.concurrent.FutureTask;

  11. //【创建线程步骤】1st,定义Runnable接口的实现类
  12. public class MyChallableThread implements Callable<Integer>
  13. {       
  14.         //【创建线程步骤】2nd,重写Callable<Integer>接口的call方法，形成线程执行体
  15.         @Override
  16.         public Integer call() throws Exception
  17.         {
  18.                 int i = 0;
  19.                
  20.                 for(;i<100;i++)
  21.                 {
  22.                         System.out.println(Thread.currentThread().getName()+" "+ i);
  23.                 }
  24.                 return i;
  25.         }
  26.        
  27.         public static void main(String[] args)
  28.         {
  29.                 //【创建线程步骤】3rd,创建Callable<Integer>实现类的实例
  30.                 MyChallableThread myChallableThread = new MyChallableThread();
  31.                
  32.                 //【创建线程步骤】4th,利用FutureTask类来包装Callable<Integer>类对象
  33.                 FutureTask<Integer> target = new FutureTask<Integer>(myChallableThread);
  34.                
  35.                 for(int i = 0;i<100;i++)
  36.                 {
  37.                         System.out.println(Thread.currentThread().getName()+" "+i);
  38.                        
  39.                         if(i == 20)
  40.                         {
  41.                                 //【创建线程步骤】5th,使用FutureTask对象作为Thread对象的target
  42.                                 new Thread(target,"有返回值的线程").start();
  43.                         }
  44.                        
  45.                         /*
  46.                         try
  47.                         {
  48.                                 System.out.println(Thread.currentThread().getName()+"的返回值是"+target.get());
  49.                         }
  50.                         catch(Exception ex)
  51.                         {
  52.                                 ex.printStackTrace();
  53.                         }
  54.                         */
  55.                 }
  56.         }

  58. }
复制代码

2）        call()方法：作为线程的执行体，可以返回值，也可以抛出异常。

7，创建线程的三种方式对比
A．        采用Runnable、Callable创建多线程的优缺点
优点：
1）        线程类只实现了Runnable或者Callable接口，还可以继承其他类；
2）        多个线程共享同一个target对象。
缺点：
编程稍复杂，如果需要访问当前线程，则必须使用Thread.currentThread()方法
B．        采用继承Thread类方式创建多线程的优缺点
优点：
编写简单，直接使用this即可获得当前线程；
缺点：
因为编程类已经继承Thread类，所以不能在继承其他类。
作者: 915816106    时间: 2015-9-22 22:07
谢谢分享



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2