1.简单Java多线程例子（继承Thread）
public class hello extends Thread{
private String name;
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 hello1 = new hello("A");
hello hello2 = new hello("B");
hello hello3 = new hello("C");
hello1.start();
hello2.start();
hello3.start();
}
}
某一次的执行结果为：
B运行...0
B运行...1
B运行...2
C运行...0
A运行...0
C运行...1
B运行...3
C运行...2
A运行...1
C运行...3
B运行...4
C运行...4
A运行...2
A运行...3
A运行...4
2.简单Java多线程例子（实现Runnable接口）
public class Test1 implements Runnable {//实现Runnable接口
private String name;
public Test1(String name) {
this.name = name;
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(name + "运行..." + i);
}
}
public static void main(String[] args) {
Test1 test1 = new Test1("线程A");
Thread demo = new Thread(test1);
Test1 test2 = new Test1("线程B");
Thread demo1 = new Thread(test2);
Test1 test3 = new Test1("线程C");
Thread demo2 = new Thread(test3);
demo.start();
demo1.start();
demo2.start();
}
}
某一次的执行结果为
线程A运行...0
线程A运行...1
线程A运行...2
线程B运行...0
线程B运行...1
线程A运行...3
线程C运行...0
线程A运行...4
线程B运行...2
线程B运行...3
线程C运行...1
线程B运行...4
线程C运行...2
线程C运行...3
线程C运行...4
Thread也是实现Runnable接口的，Thread中的run方法调用的是Runnable接口的run方法。Thread和Runnable都实现了run方法，这种操作模式其实就是代理模式。
Thread和Runnable的区别：
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
如果是一个买票系统，如果count表示的是车票的数量，使用Runnable接口
public class MyThread implements Runnable{
private int ticket = 5;
@Override
public void run() {
for (int i = 0; i < 20; i++) {
if (this.ticket > 0) {
System.out.println(Thread.currentThread().getName() + "正在买票" + this.ticket--);
// this.ticket--;//不可以分开写，线程级别，会出现不同步...
}
}
}
}
public static void main(String[] args) {
MyThread mt = new MyThread();
new Thread(mt, "1号窗口").start();
new Thread(mt, "2号窗口").start();
new Thread(mt, "3号窗口").start();
}
某一次的执行结果为
1号窗口正在买票5
3号窗口正在买票3
2号窗口正在买票4
3号窗口正在买票1
1号窗口正在买票2
总结：
实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。
建议尽量使用Runnable接口
public class Test3 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName());
}
}
public static void main(String[] args) {
Test3 test = new Test3();
new Thread(test, "A").start();
new Thread(test, "B").start();
new Thread(test).start();
}
}
某一次的执行结构为
A
B
B
B
Thread-0
Thread-0
A
A
Thread-0
如果我们没有指定名字的话，系统自动提供名字。
提醒一下大家：main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。
在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM实习在就是在操作系统中启动了一个进程。
判断线程是否启动
public class Test4 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName());
}
}
public static void main(String[] args) {
Test4 test = new Test4();
Thread demo = new Thread(test);
System.out.println("线程启动之前---》" + demo.isAlive());
demo.start();
System.out.println("线程启动之后---》" + demo.isAlive());
}
}
某一次的执行结果为
线程启动之前---》false
线程启动之后---》true
Thread-0
Thread-0
Thread-0
主线程也有可能在子线程结束之前结束。并且子线程不受影响，不会因为主线程的结束而结束。
http://www.cnblogs.com/rollenholt/archive/2011/08/28/2156357.html
To be continued···
本文出自 “阿凡达” 博客，请务必保留此出处http://shamrock.blog.51cto.com/2079212/1410738