<JAVA>浅谈多线程

进程与线程

进程是程序的一次动态执行过程，它需要经历从代码加载，代码执行到执行完毕的一个完整的过程，这个过程也是进程本身从产生，发展到最终消亡的过程。多进程操作系统能同时达运行多个进程（程序），由于 CPU 具备分时机制，所以每个进程都能循环获得自己的CPU 时间片。由于 CPU 执行速度非常快，使得所有程序好像是在同时运行一样。

多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。线程是比进程更小的执行单位，线程是进程的基础之上进行进一步的划分。所谓多线程是指一个进程在执行过程中可以产生多个更小的程序单元，这些更小的单元称为线程，这些线程可以同时存在，同时运行，一个进程可能包含多个同时执行的线程。进程与线程的区别如图所示：

在 Java 中实现多线程有两种手段，一种是继承 Thread 类，另一种就是实现 Runnable 接口。下面我们就分别来介绍这两种方式的使用..

实现 Runnable 接口

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 类

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() ;   // 调用线程主体 
    } 
}

线程的插入

在线程操作中，可以使用 join() 方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。

class MyThread implements Runnable{ // 实现Runnable接口 
    public void run(){  // 覆写run()方法 
        for(int i=0;i<50;i++){ 
            System.out.println(Thread.currentThread().getName() 
                    + "运行，i = " + i) ;  // 取得当前线程的名字 
        } 
    } 
}
public class ThreadJoinDemo{ 
    public static void main(String args[]){ 
        MyThread mt = new MyThread() ;  // 实例化Runnable子类对象 
        Thread t = new Thread(mt,"线程");     // 实例化Thread对象 
        t.start() ; // 启动线程 
        for(int i=0;i<50;i++){ 
            if(i>10){ 
                try{ 
                    t.join() ;  // 线程强制运行 
                }catch(InterruptedException e){
                } 
            } 
            System.out.println("Main线程运行 --> " + i) ; 
        } 
    } 
}

线程的休眠

在程序中允许一个线程进行暂时的休眠，直接使用 Thread.sleep() 即可实现休眠。

class MyThread implements Runnable{ // 实现Runnable接口 
    public void run(){  // 覆写run()方法 
        for(int i=0;i<50;i++){ 
            try{ 
                Thread.sleep(500) ; // 线程休眠 
            }catch(InterruptedException e){
            } 
            System.out.println(Thread.currentThread().getName() 
                    + "运行，i = " + i) ;  // 取得当前线程的名字 
        } 
    } 
}
public class ThreadSleepDemo{ 
    public static void main(String args[]){ 
        MyThread mt = new MyThread() ;  // 实例化Runnable子类对象 
        Thread t = new Thread(mt,"线程");     // 实例化Thread对象 
        t.start() ; // 启动线程 
    } 
}

猜你喜欢