Java多线程

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

Java多线程,古老的榕树,5-wow.com