4月24 -- java 线程

在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。

对于直接继承Thread的类来说，代码大致框架是：

/**
 * Test  继承Thread类,直接调用run方法
 * */
class Test extends Thread {
 
    public Test () {
 
    }
 
    public Test (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) {
        Test h1=new Test ("A");
        Test h2=new Test ("B");
        h1.run();
        h2.run();
    }
 
    private String name;
}

 【运行结果】：

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) {
        Test h1=new Test ("A");
        Test h2=new Test ("B");
        h1.start();
        h2.start();
    }

 然后运行程序，输出的可能的结果如下：

A运行     0

B运行     0

B运行     1

B运行     2

B运行     3

B运行     4

A运行     1

A运行     2

A运行     3

A运行     4

因为需要用到CPU的资源，所以每次的运行结果基本是都不一样的

注意：虽然我们在这里调用的是start（）方法，但是实际上调用的还是run（）方法的主体。

/**
 * Test 实现Runnable接口
 * */
class Test implements Runnable {
 
    public Test () {
 
    }
 
    public Test (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) {
        Test h1=new Test ("线程A");
        Thread demo= new Thread(h1);
        Test h2=new Test ("线程Ｂ");
        Thread demo1=new Thread(h2);
        demo.start();
        demo1.start();
    }
 
    private String name;
}

 【可能的运行结果】：

线程A运行     0

线程Ｂ运行     0

线程Ｂ运行     1

线程Ｂ运行     2

线程Ｂ运行     3

线程Ｂ运行     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和Runnable的区别：

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

 

/**
 * Test 继承Thread类，不能资源共享
 * */
class Test 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) {
        Test h1 = new Test ();
        Test h2 = new Test ();
        Test h3 = new Test ();
        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

我们换为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();
    }
}

 【运行结果】：

1号窗口正在买票5

1号窗口正在买票4

2号窗口正在买票3

3号窗口正在买票1

1号窗口正在买票2

 

实现Runnable接口比继承Thread类所具有的优势：

 

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

 

2）：可以避免java中的单继承的限制

 

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。