认识多线程

 

Java 多线程实现：

　　　　继承Thread类

　　　　实现Runnable接口

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("线程A ") ;     // 实例化对象
        MyThread mt2 = new MyThread("线程B ") ;     // 实例化对象
        mt1.run() ;    // 调用线程主体
        mt2.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() ;    // 调用线程主体
    }
};

运行结果：

从上面的运行结果看，确实是并发执行的，哪个线程先抢到了CPU资源，哪个线程就先执行

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 ThreadDemo03{
    public static void main(String args[]){
        MyThread mt1 = new MyThread("线程A ") ;     // 实例化对象
        mt1.start() ;    // 调用线程主体
        mt1.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() ;    // 启动多线程
    }
};

运行结果：

从运行效果可以发现，已经完成了多线程的功能

 

Thread类与Runnable接口的联系

Thread定义：
public class Thread
extends Object
implements Runnable

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

 

Thread类与Runnable接口的区别

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

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 ThreadDemo04{
    public static void main(String args[]){
        MyThread mt1 = new MyThread() ;     // 实例化对象
        MyThread mt2 = new MyThread() ;     // 实例化对象
        MyThread mt3 = new MyThread() ;     // 实例化对象
        mt1.run() ;    // 调用线程主体
        mt2.run() ;    // 调用线程主体
        mt3.run() ;    // 调用线程主体
    }
};

运行结果：

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

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 RunnableDemo02{
    public static void main(String args[]){
        MyThread mt = new MyThread() ;     // 实例化对象
        new Thread(mt).run() ;    // 调用线程主体
        new Thread(mt).run() ;    // 调用线程主体
        new Thread(mt).run() ;    // 调用线程主体
    }
};

运行效果：

 

Thread类与Runnable接口的使用结论

 

线程的状态

线程调用start()方法的时候不是立刻启动的，而是要等待CPU进行调度，调用start()实际上是调用run()方法

Thread类是Runnable的子类，使用了代理的机制完成

在使用多线程的实现中建议通过Runnable接口实现，这样可以避免由于单继承所带来的开发局限，而且通过使用Runnable接口也可以达到资源共享的目的