Java中线程的俩种方式，编码的变体

来源：互联网发布：购金蝶软件会计分录编辑：程序博客网时间：2024/04/29 20:13

1.通过继承thread，得到一个任务类。

/*注意在构造器中启动这个线程的话，很容易造成this逃逸的问题，这是要注意的* 这是通过直接集成thread来成为线程。同时在这种情况下，你可以通过调用合适的方法来* 给thread对象赋予具体的名称。*/public class SimpleThread extends  Thread {    private int countDown=5;    private static int threadCount=0;    public SimpleThread() {        super(Integer.toString(++threadCount));//这是给这个thread赋予名字。        start();    }    public String toString(){        return "#"+getName()+"("+countDown+"), ";    }    public void run() {        while (true) {            System.out.print(this);            if (--countDown == 0) {                return;            }        }    }    public static void main(String[] args) {        for (int i = 0; i < 5; i++) {            new SimpleThread();        }    }}

运行的结果为：

#1(5),
#2(5),
#3(5),
#3(4),
#3(3),
#3(2),
#4(5),
#2(4),
#5(5),
#5(4),
#1(4),
#5(3),
#5(2),
#2(3),
#2(2),
#2(1),
#4(4),
#4(3),
#4(2),
#4(1),
#3(1),
#5(1),
#1(3),
#1(2),
#1(1),

2.通过实现Runnable接口，来得到一个任务类。

//注意，Start()是在构造器中调用的。这个实例相当的简单，因此可能是安全的。但是应该注意到//在构造器重启动线程可能会变得很有问题。因为另外一个任务可能会在构造器结束以前就开始执行了//这意味着该任务能够访问处于不稳定状态的对象。这是优选Executor而不是显式地创建Thread对象的//另外一个很重要的原因。public class SelfManaged implements  Runnable {    private int countDown=5;    private Thread t = new Thread(this);    public SelfManaged() {        t.start();    }    public String toString(){        return  Thread.currentThread().getName()+"("+countDown+")";    }    @Override    public void run() {        while (true) {            System.out.println(this);            if (--countDown == 0) {                return;            }        }    }    public static void main(String[] args) {        for (int i = 0; i < 5; i++) {            new SelfManaged();        }    }}

最后运行的结果为：
Thread-0(5)
Thread-2(5)
Thread-1(5)
Thread-1(4)
Thread-2(4)
Thread-2(3)
Thread-2(2)
Thread-2(1)
Thread-0(4)
Thread-0(3)
Thread-0(2)
Thread-0(1)
Thread-3(5)
Thread-1(3)
Thread-3(4)
Thread-4(5)
Thread-4(4)
Thread-4(3)
Thread-4(2)
Thread-4(1)
Thread-1(2)
Thread-1(1)
Thread-3(3)
Thread-3(2)
Thread-3(1)

3.为线程设置优先级。但是设置优先级只是一个建议。具体是否执行的话，还是要看系统内部的调度。

public class SimplePriorities implements  Runnable {    private int countDown=5;    private volatile  double d;    private int priority;    public SimplePriorities(int priority) {        this.priority=priority;    }    public String toString(){        return Thread.currentThread()+":"+countDown;    }    @Override    public void run() {        Thread.currentThread().setPriority(priority);//为这个线程设置优先级。        while (true) {            for (int i = 0; i < 10000; i++) {                d += (Math.PI + Math.E)/(double)i;                if (i / 1000 == 0) {                    Thread.yield();                }            }            System.out.println(this);            if (--countDown == 0) {                return;            }        }    }    public static void main(String[] args) {        ExecutorService exec= Executors.newCachedThreadPool();        for (int i = 0; i < 5; i++) {            exec.execute(new SimplePriorities(Thread.MAX_PRIORITY));            exec.execute(new SimplePriorities(Thread.MIN_PRIORITY));            exec.shutdown();        }    }}

4继承thread和实现runnable之间的区别：

1.如是是实现了Runnable接口的话，那么就为实现多继承提供了方便。因为java中，只允许单继承。

2.实现runnable接口可以实现资源的共享。

这就是它们之间的最大的区别。

下面以一个买票的例子来说明它们之间的区别。

class MyThread extends Thread{  
private int ticket=10;  
public void run(){  
for(int i=0;i<20;i++){  
if(this.ticket>0){  
System.out.println("卖票：ticket"+this.ticket--);  
}  
}  
}  
};

下面通过三个线程对象，同时卖票：

package org.demo.dff;  
public class ThreadTicket {  
public static void main(String[] args) {  
MyThread mt1=new MyThread();  
MyThread mt2=new MyThread();  
MyThread mt3=new MyThread();  
mt1.start();//每个线程都各卖了10张，共卖了30张票  
mt2.start();//但实际只有10张票，每个线程都卖自己的票  
mt3.start();//没有达到资源共享  
}  
}

package org.demo.runnable;
class MyThread implements Runnable{
private int ticket=10;
public void run(){
for(int i=0;i<20;i++){
if(this.ticket>0){
System.out.println("卖票：ticket"+this.ticket--);
}
}
}
}
package org.demo.runnable;
public class RunnableTicket {
public static void main(String[] args) {
MyThread mt=new MyThread();
new Thread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一
new Thread(mt).start();//个实例化对象mt，就会出现异常
new Thread(mt).start();
}
};

但是这个程序是有问题的。可能会涉及到锁的问题。可以使用Synchronized来进行锁定。这是要注意的。

0 0