Java 多线程(1)-Thread和Runnable
2015-12-26 13:41
603 查看
一提到Java多线程,首先想到的是Thread继承和Runnable的接口实现
Thread继承
Runnable接口实现
两者都可以实现多线程程序的创建。实际上,我们查看Thread的代码实现,也可以发现,Thread实际上也是实现了Runnable接口。
那么Thread 和Runnabe 有什么区别呢?
The most common difference is
When you extends Thread class, after that you can’t extend any other class which you required. (As you know, Java does not allow inheriting more than one class).
When you implements Runnable, you can save a space for your class to extend any other class in future or now.
However, the significant difference is.
When you extends Thread class, each of your thread creates unique object and associate with it.
When you implements Runnable, it shares the same object to multiple threads.
Thread vs Runnable
执行结果输出如下:
ImplementsRunnable : Counter : 1
ImplementsRunnable : Counter : 2
ImplementsRunnable : Counter : 3
ExtendsThread : Counter : 1
ExtendsThread : Counter : 1
ExtendsThread : Counter : 1
In the Runnable interface approach, only one instance of a class is being created and it has been shared by different threads. So the value of counter is incremented for each and every thread access.
Whereas, Thread class approach, you must have to create separate instance for every thread access. Hence different memory is allocated for every class instances and each has separate counter, the value remains same, which means no increment will happen because none of the object reference is same.
Which one is best to use?
Ans : Very simple, based on your application requirements you will use this appropriately. But I would suggest, try to use interface inheritance i.e., implements Runnable.
Thread继承
public class MyThread extends Thread { public void run(){ int i = 0; System.out.println("--------------"+i++); } }
Runnable接口实现
public class RunnableImpl implements Runnable { private long value = 0; @Override public synchronized void run() { while(ThreadMain.tickets > 0){ System.out.println(Thread.currentThread().getName()+ "------------"+ --ThreadMain.tickets); } } }
两者都可以实现多线程程序的创建。实际上,我们查看Thread的代码实现,也可以发现,Thread实际上也是实现了Runnable接口。
public class Thread implements Runnable { /* Make sure registerNatives is the first thing <clinit> does. */ private static native void registerNatives(); static { registerNatives(); } private char name[]; private int priority; private Thread threadQ; private long eetop; ...... }
那么Thread 和Runnabe 有什么区别呢?
The most common difference is
When you extends Thread class, after that you can’t extend any other class which you required. (As you know, Java does not allow inheriting more than one class).
When you implements Runnable, you can save a space for your class to extend any other class in future or now.
However, the significant difference is.
When you extends Thread class, each of your thread creates unique object and associate with it.
When you implements Runnable, it shares the same object to multiple threads.
Thread vs Runnable
class ImplementsRunnable implements Runnable { private int counter = 0; public void run() { counter++; System.out.println("ImplementsRunnable : Counter : " + counter); } } class ExtendsThread extends Thread { private int counter = 0; public void run() { counter++; System.out.println("ExtendsThread : Counter : " + counter); } } public class ThreadVsRunnable { public static void main(String args[]) throws Exception { // Multiple threads share the same object. ImplementsRunnable rc = new ImplementsRunnable(); Thread t1 = new Thread(rc); t1.start(); Thread.sleep(1000); // Waiting for 1 second before starting next thread Thread t2 = new Thread(rc); t2.start(); Thread.sleep(1000); // Waiting for 1 second before starting next thread Thread t3 = new Thread(rc); t3.start(); // Creating new instance for every thread access. ExtendsThread tc1 = new ExtendsThread(); tc1.start(); Thread.sleep(1000); // Waiting for 1 second before starting next thread ExtendsThread tc2 = new ExtendsThread(); tc2.start(); Thread.sleep(1000); // Waiting for 1 second before starting next thread ExtendsThread tc3 = new ExtendsThread(); tc3.start(); } }
执行结果输出如下:
ImplementsRunnable : Counter : 1
ImplementsRunnable : Counter : 2
ImplementsRunnable : Counter : 3
ExtendsThread : Counter : 1
ExtendsThread : Counter : 1
ExtendsThread : Counter : 1
In the Runnable interface approach, only one instance of a class is being created and it has been shared by different threads. So the value of counter is incremented for each and every thread access.
Whereas, Thread class approach, you must have to create separate instance for every thread access. Hence different memory is allocated for every class instances and each has separate counter, the value remains same, which means no increment will happen because none of the object reference is same.
Which one is best to use?
Ans : Very simple, based on your application requirements you will use this appropriately. But I would suggest, try to use interface inheritance i.e., implements Runnable.
相关文章推荐
- Java基础学习总结(1)——equals方法
- Java基础学习总结(1)——equals方法
- 25个Java机器学习工具&库
- Eclipse安装WindowBuilder
- eclipse--.classpath .project文件的含义
- Java随机生成验证码
- 【Java学习笔记】——Statement & PrepareStatement
- MAC上安装JAVA 1.8,安装不成功,以及配置JAVA_HOME遇到的问题
- java.lang.String源码分析(1)
- Java+MySQL图书管理系统
- Java系列: JAVA字符串格式化-String.format()的使用(zz)
- java编码解码过程
- JAVA多线程--信号量(Semaphore)
- 【事务系列一】事务概念与特性
- Java 中日期的几种常见操作 —— 取值、转换、加减、比较
- JAVA设计模式之单例模式
- java list与Json转换
- 通过Java反射来理解泛型的本质
- java字符串操作简单总结
- Java中的责任链模式