疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java多线程深入理解


 

 
在java中要想实现多线程,有两种手段,一种是继续Thread类,另外一种是实现Runable接口。
 
对于直接继承Thread的类来说,代码大致框架是:
 
class 类名 extends Thread{ 
方法1; 
方法2; 
… 
public void run(){ 
// other code… 
属性1; 
属性2; 
… 
先看一个简单的例子:
 
/**
 * @author Hashsound 继承Thread类,直接调用run方法
 * */ 
class hello extends Thread { 
   
    private String name; 
   
    public hello() { 
    } 
   
    public hello(String name) { 
        this.name = name; 
    } 
   
    public void run() { 
        for (int i = 0; i < 5; i++) { 
            System.out.println(name + "运行 " + i); 
        } 
    } 
   
    public static void main(String[] args) { 
        hello h1 = new hello("A"); 
        hello h2 = new hello("B"); 
        h1.run(); 
        h2.run(); 
    } 
【运行结果】:
 
复制代码
复制代码
A运行     0
A运行     1
A运行     2
A运行     3
A运行     4
B运行     0
B运行     1
B运行     2
B运行     3
B运行     4
复制代码
复制代码
我们会发现这些都是顺序执行的,说明我们的调用方法不对,应该调用的是start()方法。
当我们把上面的主函数修改为如下所示的时候:
 
public static void main(String[] args) { 
        hello h1=new hello("A"); 
        hello h2=new hello("B"); 
        h1.start(); 
        h2.start(); 
然后运行程序,输出的可能的结果如下:
 
复制代码
复制代码
B运行 0
B运行 1
B运行 2
A运行 0
A运行 1
A运行 2
B运行 3
B运行 4
A运行 3
A运行 4
复制代码
复制代码
因为需要用到CPU的资源,所以每次的运行结果基本是都不一样的,呵呵。
注意:虽然我们在这里调用的是start()方法,但是实际上调用的还是run()方法的主体。
那么:为什么我们不能直接调用run()方法呢?
我的理解是:线程的运行需要本地操作系统的支持。
如果你查看start的源代码的时候,会发现:
 
 
18
public synchronized void start() { 
   
    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added 
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */ 
     if (threadStatus != 0 || this != me) 
            throw new IllegalThreadStateException(); 
        group.add(this); 
        start0(); 
        if (stopBeforeStart) { 
        stop0(throwableFromStop); 
    } 
private native void start0(); 
注意我用红色加粗的那一条语句,说明此处调用的是start0()。并且这个这个方法用了native关键字,次关键字表示调用本地操作系统的函数。因为多线程的实现需要本地操作系统的支持。
但是start方法重复调用的话,会出现java.lang.IllegalThreadStateException异常。
通过实现Runnable接口:
大致框架是:
 
来先看一个小例子吧:
 
 
class 类名 implements Runnable{ 
方法1; 
方法2; 
… 
public void run(){ 
// other code… 
属性1; 
属性2; 
… 
 
/**
 * @author Hashsound 实现Runnable接口
 * */ 
class hello implements Runnable { 
    
    public hello() { 
    
    } 
    
    public hello(String name) { 
        this.name = name; 
    } 
    
    public void run() { 
        for (int i = 0; i < 5; i++) { 
            System.out.println(name + "运行     " + i); 
        } 
    } 
    
    public static void main(String[] args) { 
        hello h1=new hello("线程A"); 
        Thread demo= new Thread(h1); 
        hello h2=new hello("线程B"); 
        Thread demo1=new Thread(h2); 
        demo.start(); 
        demo1.start(); 
    } 
    private String name; 
}
【可能的运行结果】:
 
复制代码
复制代码
线程A运行     0
线程B运行    0
线程B运行    1
线程B运行    2
线程B运行    3
线程B运行    4
线程A运行     1
线程A运行     2
线程A运行     3
线程A运行     4
复制代码
复制代码
关于选择继承Thread还是实现Runnable接口?
其实Thread也是实现Runnable接口的:
 
class Thread implements Runnable { 
    //… 
public void run() { 
        if (target != null) { 
             target.run(); 
        } 
     } 
其实Thread中的run方法调用的是Runnable接口的run方法。不知道大家发现没有,Thread和Runnable都实现了run方法,这种操作模式其实就是代理模式。
 
Thread和Runnable的区别:
 
如果一个类继承Thread,则不适合资源共享。但是如果实现了Runable接口的话,则很容易的实现资源共享。
/**
 * @author Rollen-Holt 继承Thread类,不能资源共享
 * */ 
class hello extends Thread { 
    public void run() { 
        for (int i = 0; i < 7; i++) { 
            if (count > 0) { 
                System.out.println("count= " + count--); 
            } 
        } 
    } 
    
    public static void main(String[] args) { 
        hello h1 = new hello(); 
        hello h2 = new hello(); 
        hello h3 = new hello(); 
        h1.start(); 
        h2.start(); 
        h3.start(); 
    } 
    private int count = 5; 
【运行结果】:
 
复制代码
复制代码
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
复制代码
复制代码
大家可以想象,如果这个是一个买票系统的话,如果count表示的是车票的数量的话,说明并没有实现资源的共享。
 
我们换为Runnable接口
 
class MyThread implements Runnable{ 
    
    private int ticket = 5;  //5张票 
    
    public void run() { 
        for (int i=0; i<=20; i++) { 
            if (this.ticket > 0) { 
                System.out.println(Thread.currentThread().getName()+ "正在卖票"+this.ticket--); 
            } 
        } 
    } 
public class lzwCode { 
        
    public static void main(String [] args) { 
        MyThread my = new MyThread(); 
        new Thread(my, "1号窗口").start(); 
        new Thread(my, "2号窗口").start(); 
        new Thread(my, "3号窗口").start(); 
    } 
【运行结果】:
 
count= 5
count= 4
count= 3
count= 2
count= 1
总结一下吧:
 
实现Runnable接口比继承Thread类所具有的优势:
 
1):适合多个相同的程序代码的线程去处理同一个资源
 
2):可以避免java中的单继承的限制
 
3):增加程序的健壮性,代码可以被多个线程共享,代码和数据独立。
所以,本人建议大家尽量实现接口。
 
/**
 * @author Hashsound
 * 取得线程的名称
 * */ 
class hello implements Runnable { 
    public void run() { 
        for (int i = 0; i < 3; i++) { 
            System.out.println(Thread.currentThread().getName()); 
        } 
    } 
    
    public static void main(String[] args) { 
        hello he = new hello(); 
        new Thread(he,"A").start(); 
        new Thread(he,"B").start(); 
        new Thread(he).start(); 
    } 
【运行结果】:
 
复制代码
复制代码
A
A
A
B
B
B
Thread-0
Thread-0
Thread-0
复制代码
复制代码
说明如果我们没有指定名字的话,系统自动提供名字。
提醒一下大家:main方法其实也是一个线程。在java中所以的线程都是同时启动的,至于什么时候,哪个先执行,完全看谁先得到CPU的资源。
在java中,每次程序运行至少启动2个线程。一个是main线程,一个是垃圾收集线程。因为每当使用java命令执行一个类的时候,实际上都会启动一个JVM,每一个jVM实习在就是在操作系统中启动了一个进程。
 
判断线程是否启动
 
/**
 * @author Hashsound 判断线程是否启动
 * */ 
class hello implements Runnable { 
    public void run() { 
        for (int i = 0; i < 3; i++) { 
            System.out.println(Thread.currentThread().getName()); 
        } 
    } 
    
    public static void main(String[] args) { 
        hello he = new hello(); 
        Thread demo = new Thread(he); 
        System.out.println("线程启动之前---》" + demo.isAlive()); 
        demo.start(); 
        System.out.println("线程启动之后---》" + demo.isAlive()); 
    } 
【运行结果】
 
线程启动之前---》false
线程启动之后---》true
Thread-0
Thread-0
Thread-0
主线程也有可能在子线程结束之前结束。并且子线程不受影响,不会因为主线程的结束而结束。
 
线程的强制执行:
 
/**
 * @author Hashsound 线程的强制执行
 * */ 
class hello implements Runnable { 
    public void run() { 
        for (int i = 0; i < 3; i++) { 
            System.out.println(Thread.currentThread().getName()); 
        } 
    } 
    
    public static void main(String[] args) { 
        hello he = new hello(); 
        Thread demo = new Thread(he,"线程"); 
        demo.start(); 
        for(int i=0;i<50;++i){ 
            if(i>10){ 
                try{ 
                    demo.join();  //强制执行demo 
                }catch (Exception e) { 
                    e.printStackTrace(); 
                } 
            } 
            System.out.println("main 线程执行-->"+i); 
        } 
    } 
【运行的结果】:
 
复制代码
复制代码
main 线程执行-->0
main 线程执行-->1
main 线程执行-->2
main 线程执行-->3
main 线程执行-->4
main 线程执行-->5
main 线程执行-->6
main 线程执行-->7
main 线程执行-->8
main 线程执行-->9
main 线程执行-->10
线程
线程
线程
main 线程执行-->11
main 线程执行-->12
main 线程执行-->13
...
复制代码
复制代码
线程的休眠:
 
复制代码
复制代码
/** 
 * @author Hashsound 线程的休眠 
 * */  
class hello implements Runnable {  
    public void run() {  
        for (int i = 0; i < 3; i++) {  
            try {  
                Thread.sleep(2000);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
            System.out.println(Thread.currentThread().getName() + i);  
        }  
    }  
   
    public static void main(String[] args) {  
        hello he = new hello();  
        Thread demo = new Thread(he, "线程");  
        demo.start();  
    }  
}  
复制代码
复制代码
【运行结果】:(结果每隔2s输出一个)
 
线程0
线程1
线程2
线程的中断:
 
复制代码
复制代码
/** 
 * @author Hashsound 线程的中断 
 * */  
class hello implements Runnable {  
    public void run() {  
        System.out.println("执行run方法");  
        try {  
            Thread.sleep(10000);  
            System.out.println("线程完成休眠");  
        } catch (Exception e) {  
            System.out.println("休眠被打断");  
            return;  //返回到程序的调用处  
        }  
        System.out.println("线程正常终止");  
    }  
   
    public static void main(String[] args) {  
        hello he = new hello();  
        Thread demo = new Thread(he, "线程");  
        demo.start();  
        try{  
            Thread.sleep(2000);  
        }catch (Exception e) {  
            e.printStackTrace();  
        }  
        demo.interrupt(); //2s后中断线程  
    }  
}  
复制代码
复制代码
【运行结果】:
 
执行run方法
休眠被打断
 
在java程序中,只要前台有一个线程在运行,整个java程序进程不会小时,所以此时可以设置一个后台线程,这样即使java进程小时了,此后台线程依然能够继续运行。
 
/**
 * @author Hashsound 后台线程
 * */ 
class hello implements Runnable { 
    public void run() { 
        while (true) { 
            System.out.println(Thread.currentThread().getName() + "在运行"); 
        } 
    } 
    
    public static void main(String[] args) { 
        hello he = new hello(); 
        Thread demo = new Thread(he, "线程"); 
        demo.setDaemon(true); 
        demo.start(); 
    } 
虽然有一个死循环,但是程序还是可以执行完的。因为在死循环中的线程操作已经设置为后台运行了。
 
线程的优先级:
 
 
/**
 * @author Hashsound 线程的优先级
 * */ 
class hello implements Runnable { 
    public void run() { 
        for(int i=0;i<5;++i){ 
            System.out.println(Thread.currentThread().getName()+"运行"+i); 
        } 
    } 
    
    public static void main(String[] args) { 
        Thread h1=new Thread(new hello(),"A"); 
        Thread h2=new Thread(new hello(),"B"); 
        Thread h3=new Thread(new hello(),"C"); 
        h1.setPriority(8); 
        h2.setPriority(2); 
        h3.setPriority(6); 
        h1.start(); 
        h2.start(); 
        h3.start(); 
    } 
【运行结果】:
 
复制代码
复制代码
A运行0
A运行1
A运行2
A运行3
A运行4
B运行0
C运行0
C运行1
C运行2
C运行3
C运行4
B运行1
B运行2
B运行3
B运行4
复制代码
复制代码
但是请读者不要误以为优先级越高就先执行。谁先执行还是取决于谁先去的CPU的资源、
 
另外,主线程的优先级是5.
 
线程的礼让。
 
在线程操作中,也可以使用yield()方法,将一个线程的操作暂时交给其他线程执行。