认识多线程

1，进程与线程

　　对于WORD来讲，每次启动一个WORD相当于操作系统上分配了一个进程。

　　线程实际上是进程的进一步划分，从WORD来看，可以把拼写检查当作一个线程处理，当然，会同时存在多个线程。

　　如果进程没有了，线程肯定消失了；但是线程消失，进程未必消失。所有线程都是在进程的基础之上并发（同时运行）。

　　现在如果同时运行多个任务，则所有的线程资源是共享的，被所有线程所公用。但是程序处理需要CPU，在同一个时间段会有多个程序执行，但是同一个时间点只能存在

一个程序运行，也就是说，所有程序都要抢占CPU资源。

　　

2，JAVA多线程实现

　　在Java中实现多线程可以采用以下两种方式：

　　1）继承Thread类。

　　2）实现Runnable接口。

2.1 Thread类

　　Thread类是在java.lang包中定义的，java.lang包会在程序运行时候自动导入，无需手动import导入。

　　一个类继承了Thread类之后，那么此类具有了多线程的操作功能。

　　在Thread类的子类中，必须明确覆写run()方法，此方法为线程的主体。

　　一个线程子类的实现如下：

class MyThread extends Thread{    // 继承Thread类，作为线程的实现类
    private String name ;        // 表示线程的名称
    public MyThread(String name){
        this.name = name ;        // 通过构造方法配置name属性
    }
    public void run(){    // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<10;i++){
            System.out.println(name + "运行，i = " + i) ;
        }
    }
};
public class ThreadDemo01{
    public static void main(String args[]){
        MyThread mt1 = new MyThread("线程1 ") ;     // 实例化对象
        MyThread mt2 = new MyThread("线程2 ") ;     // 实例化对象
        mt1.run() ;    // 调用线程主体
        mt2.run() ;    // 调用线程主体
    }
};

运行结果：

线程1运行，i=0
线程1运行，i=1
线程1运行，i=2
线程1运行，i=3
线程1运行，i=4
线程1运行，i=5
线程1运行，i=6
线程1运行，i=7
线程1运行，i=8
线程1运行，i=9
线程2运行，i=0
线程2运行，i=1
线程2运行，i=2
线程2运行，i=3
线程2运行，i=4
线程2运行，i=5
线程2运行，i=6
线程2运行，i=7
线程2运行，i=8
线程2运行，i=9

　　以上程序是先执行完A,后执行B，并没有达到所谓的并发执行效果。

　　因为以上程序还是按照古老的形式调用的，通过：对象.方法。但是如果要想启动一个线程，必须使用Thead类中定义的start()方法。

　　一旦调用start()方法，实际上最终调用的是run()方法。修改如下：

class MyThread extends Thread{    // 继承Thread类，作为线程的实现类
    private String name ;        // 表示线程的名称
    public MyThread(String name){
        this.name = name ;        // 通过构造方法配置name属性
    }
    public void run(){    // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<10;i++){
            System.out.println(name + "运行，i = " + i) ;
        }
    }
};
public class ThreadDemo02{
    public static void main(String args[]){
        MyThread mt1 = new MyThread("线程A ") ;     // 实例化对象
        MyThread mt2 = new MyThread("线程B ") ;     // 实例化对象
        mt1.start() ;    // 调用线程主体
        mt2.start() ;    // 调用线程主体
    }
};

运行结果：

线程A 运行，i = 0
线程B 运行，i = 0
线程A 运行，i = 1
线程B 运行，i = 1
线程A 运行，i = 2
线程B 运行，i = 2
线程A 运行，i = 3
线程A 运行，i = 4
线程A 运行，i = 5
线程A 运行，i = 6
线程A 运行，i = 7
线程A 运行，i = 8
线程A 运行，i = 9
线程B 运行，i = 3
线程B 运行，i = 4
线程B 运行，i = 5
线程B 运行，i = 6
线程B 运行，i = 7
线程B 运行，i = 8
线程B 运行，i = 9

从以上效果来看，确实是并发执行的，哪个线程先抢占CPU资源，那个线程就执行。

注意：

　　一个线程只能启动一次，启动多次就会出错。如下：

package Thread1;
class MyThread extends Thread{    // 继承Thread类，作为线程的实现类
    private String name ;        // 表示线程的名称
    public MyThread(String name){
        this.name = name ;        // 通过构造方法配置name属性
    }
    public void run(){    // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<10;i++){
            System.out.println(name + "运行，i = " + i) ;
        }
    }
};
public class demo1{
    public static void main(String args[]){
        MyThread mt1 = new MyThread("线程A ") ;     // 实例化对象
        MyThread mt2 = new MyThread("线程B ") ;     // 实例化对象
        mt1.start() ;    // 调用线程主体
        mt1.start() ;    // 错误
    }
};

运行结果：

线程A 运行，i = 0
线程A 运行，i = 1
线程A 运行，i = 2
线程A 运行，i = 3
Exception in thread "main" 线程A 运行，i = 4
线程A 运行，i = 5
线程A 运行，i = 6
线程A 运行，i = 7
线程A 运行，i = 8
线程A 运行，i = 9
java.lang.IllegalThreadStateException
    at java.lang.Thread.start(Unknown Source)
    at Thread1.demo1.main(demo1.java:18)

3. Runnable接口实现多线程

　　通过Runnable接口的方式实现多线程，Runnable接口只定义了一个抽象方法。

　　private void run();

　　通过Runnable接口实现多线程：

class 类名称 implements Runnable{
        
           属性...;
           方法....；
           public void run(){
        }
　　}   

　　如果要想启动线程，则肯定依靠Thread类，但是如果之前直接继承了Thread类，则可以将start()方法直接继承下来使用，但是在Runnable接口中，

并没有start()方法，启动多线程一定要使用start()方法。

　　Thread类的构造：

public Thread ( Runnable  target)

　　就利用以上构造方法，启动多线程。

　　　RunnableThread mt = new RunnableThread("线程B ") ;     // 实例化对象
     Thread t1 = new Thread(mt) ;        // 实例化Thread类对象
     t1.start() ;    // 启动多线程

　　例子如下：

class MyThread implements Runnable{    // 实现Runnable接口，作为线程的实现类
    private String name ;        // 表示线程的名称
    public MyThread(String name){
        this.name = name ;        // 通过构造方法配置name属性
    }
    public void run(){    // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<10;i++){
            System.out.println(name + "运行，i = " + i) ;
        }
    }
};
public class RunnableDemo01{
    public static void main(String args[]){
        MyThread mt1 = new MyThread("线程A ") ;     // 实例化对象
        MyThread mt2 = new MyThread("线程B ") ;     // 实例化对象
        Thread t1 = new Thread(mt1) ;        // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;        // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
};

运行结果：

线程A 运行，i = 0
线程B 运行，i = 0
线程A 运行，i = 1
线程B 运行，i = 1
线程A 运行，i = 2
线程B 运行，i = 2
线程A 运行，i = 3
线程A 运行，i = 4
线程B 运行，i = 3
线程B 运行，i = 4
线程A 运行，i = 5
线程B 运行，i = 5
线程A 运行，i = 6
线程B 运行，i = 6
线程A 运行，i = 7
线程B 运行，i = 7
线程A 运行，i = 8
线程B 运行，i = 8
线程A 运行，i = 9
线程B 运行，i = 9

　　从运行结果可以看出，已经完成多线程功能。

4.Thread类与Runnable接口

4.1Thread类与Runnable接口的联系

　　Thread类定义：

public class  Thread
Extends Object
implements Runnable

　　从定义格式可以发现，Thread类也是Runnable接口子类。

　　从类的关系上看，之前的做法非常类似代理设计模式！Thread类完成比主体线程更多的操作，例如：分配CPU资源，判断是否已经启动等

4.2 Thread类与Runnable接口的区别

　　使用Thread类，在操作多线程的时候无法达到资源共享的目的，而使用Runnable接口实现的多线程操作可以实现资源共享。

　　使用Thread类的操作：

package Thread1;
class MyThread extends Thread{    // 继承Thread类，作为线程的实现类
    private int ticket = 5 ;        // 表示一共有5张票
    public void run(){    // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<100;i++){
            if(this.ticket>0){
                System.out.println("卖票：ticket = " + ticket--) ;
            }
        }
    }
};
public class demo1{
    public static void main(String args[]){
        MyThread mt1 = new MyThread() ;     // 实例化对象
        MyThread mt2 = new MyThread() ;     // 实例化对象
        MyThread mt3 = new MyThread() ;     // 实例化对象
        mt1.run() ;    // 调用线程主体
        mt2.run() ;    // 调用线程主体
        mt3.run() ;    // 调用线程主体
    }
};

运行结果：

卖票：ticket = 5
卖票：ticket = 4
卖票：ticket = 3
卖票：ticket = 2
卖票：ticket = 1
卖票：ticket = 5
卖票：ticket = 4
卖票：ticket = 3
卖票：ticket = 2
卖票：ticket = 1
卖票：ticket = 5
卖票：ticket = 4
卖票：ticket = 3
卖票：ticket = 2
卖票：ticket = 1

　　发现一个卖出了15张票，也就是三个线程各自卖各自的5张票，也就是说现在没有达到资源共享的目的。

　　因为在每一个MyThread对象中都包含各自的ticket属性。

　　如果现在使用Runnable接口呢？同样启动多个线程，那么，所有的线程将卖出共同的五张票。

package Thread1;
class MyThread implements Runnable{    // 继承Thread类，作为线程的实现类
    private int ticket = 5 ;        // 表示一共有5张票
    public void run(){    // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<100;i++){
            if(this.ticket>0){
                System.out.println("卖票：ticket = " + ticket--) ;
            }
        }
    }
};
public class demo1{
    public static void main(String args[]){
        MyThread mt = new MyThread() ;     // 实例化对象
        Thread t1=new Thread(mt) ;    // 调用线程主体
        Thread t2=new Thread(mt) ;    // 调用线程主体
        Thread t3=new Thread(mt) ;    // 调用线程主体
        t1.run();
        t2.run();
        t3.run();
    }
};

　　结果：

卖票：ticket = 5
卖票：ticket = 4
卖票：ticket = 3
卖票：ticket = 2
卖票：ticket = 1

　　可见，虽然现在启动了三个线程，但是三个线程一共才卖出了五张票，所以达到了资源共享的目的。

　　这是因为三个Thread都是调用了同一个Runnable子类的对象MyThread 。

4.3 Thread类与Runnable接口比较的结论。

　　实现Runnable接口比继承Thread类有如下的优点：

　　1）适合多个相同程序代码的线程去处理同一个资源（资源共享）

　　2）可以避免由于单继承局限所带来的影响。

　　3）增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的(共享)。

　　综合来看，开发中Runnable接口最合适。

在以后的章节中，使用多线程时候，都将以Runnable接口的实现作为操作的重点。