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

主线程也有可能在子线程结束之前结束。并且子线程不受影响，不会因为主线程的结束而结束。

线程的强制执行

public class Test5 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
    public static void main(String[] args) {
        Test5 t = new Test5();
        Thread demo = new Thread(t, "线程");
        demo.start();
        for (int i = 0; i < 10; ++i) {
            if (i > 5) {
                try {
                    demo.join(); // 强制执行demo
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main 线程执行-->" + i);
        }
    }
}

某一次的执行结果为

main 线程执行-->0

线程

线程

线程

线程

线程

线程

线程

线程

线程

线程

main 线程执行-->1

main 线程执行-->2

main 线程执行-->3

main 线程执行-->4

main 线程执行-->5

main 线程执行-->6

main 线程执行-->7

main 线程执行-->8

main 线程执行-->9

线程的休眠

public class Test6 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            try {
                System.out.println(new Date());
                Thread.sleep(2000);//休眠2000毫秒
                System.out.println(new Date());
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
    public static void main(String[] args) {
        Test6 t = new Test6();
        Thread demo = new Thread(t, "线程");
        demo.start();
    }
}

某一次的执行结果

Thu May 15 15:01:11 CST 2014

Thu May 15 15:01:13 CST 2014

线程0

Thu May 15 15:01:13 CST 2014

Thu May 15 15:01:15 CST 2014

线程1

Thu May 15 15:01:15 CST 2014

Thu May 15 15:01:17 CST 2014

线程2

线程的中断

public class Test7 implements Runnable {
    public void run() {
        System.out.println("执行run方法");
        System.out.println(new Date());
        try {
            Thread.sleep(10000);
            System.out.println("线程完成休眠");
        } catch (Exception e) {
            System.out.println("休眠被打断");
            return; // 返回到程序的调用处
        }
        System.out.println("线程正常终止");
    }
    public static void main(String[] args) {
        Test7 t = new Test7();
        Thread demo = new Thread(t, "线程");
        demo.start();
        try {
            Thread.sleep(2000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        demo.interrupt(); // 2s后中断线程
        System.out.println(new Date());
    }
}

某一次的执行结果

执行run方法

Thu May 15 15:05:04 CST 2014

Thu May 15 15:05:06 CST 2014

休眠被打断

守护线程

public class Test8 implements Runnable{
    public void run() {
        while (true) {
            System.out.println(Thread.currentThread().getName() + "在运行");
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Test8 t = new Test8();
        Thread demo = new Thread(t, "线程");
        demo.setDaemon(true);//守护线程：守护线程则是用来服务用户线程的
//如果没有其他用户线程在运行，那么就没有可服务对象，也就没有理由继续下去。
        demo.start();
        System.out.println("Hello world!!!");
    }
}

执行结果

Hello world!!!

线程在运行

线程在运行

线程在运行

线程在运行

线程在运行

如果没有System.out.println("Hello world!!!");这句，run方法里面的语句不会执行

线程的优先级

public class Test9 implements Runnable {
    public void run() {
        for (int i = 0; i < 5; ++i) {
            System.out.println(Thread.currentThread().getName() + "运行" + i);
        }
    }
    public static void main(String[] args) {
        Thread h1 = new Thread(new Test9(), "A");
        Thread h2 = new Thread(new Test9(), "B");
        Thread h3 = new Thread(new Test9(), "C");
        h1.setPriority(8);
        h2.setPriority(2);
        h3.setPriority(6);
        h1.start();
        h2.start();
        h3.start();
    }
}

某一次的执行结果

A运行0

A运行1

A运行2

B运行0

C运行0

B运行1

A运行3

B运行2

C运行1

B运行3

A运行4

B运行4

C运行2

C运行3

C运行4

谁先执行还是取决于谁先去的CPU的资源，主线程的优先级是5

线程的礼让

在线程操作中，也可以使用yield（）方法，将一个线程的操作暂时交给其他线程执行

public class Test10 implements Runnable {
    public void run() {
        for (int i = 0; i < 5; ++i) {
            System.out.println(Thread.currentThread().getName() + "运行" + i);
            if (i == 2) {
                System.out.println("线程的礼让");
                Thread.currentThread().yield();//将一个线程的操作暂时交给其他线程执行
            }
        }
    }
    public static void main(String[] args) {
        Thread h1 = new Thread(new Test10(), "A");
        Thread h2 = new Thread(new Test10(), "B");
        h1.start();
        h2.start();
    }
}

某一次的执行结果

A运行0

B运行0

B运行1

A运行1

B运行2

线程的礼让

B运行3

B运行4

A运行2

线程的礼让

A运行3

A运行4

线程同步

在买票的程序中需要考虑线程同步保证数据不出错

格式

synchronized（同步对象）{
                                                                                  
 //需要同步的代码
                                                                                  
}

例

public class Test11 implements Runnable {
    private int count = 5;
    @Override
    public void run() {
        for (int i = 0; i < 10; ++i) {
            synchronized (this) {//线程同步
                if (count > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println(count--);
                }
            }
        }
    }
    public static void main(String[] args) {
        Test11 t = new Test11();
        Thread thread1 = new Thread(t);
        Thread thread2 = new Thread(t);
        Thread thread3 = new Thread(t);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

执行结果

5

4

3

2

1

每秒钟输出一个

也可以采用同步方法。

语法格式为

synchronized 方法返回类型方法名（参数列表）{
                                                          
    // 其他代码
                                                          
}

采用同步方法解决上面的问题

public class Test12 implements Runnable {
    private int count = 5;
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            sale();
        }
    }
    public synchronized void sale() {// 同步方法
        if (count > 0) {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(count--);
        }
    }
                                                      
    public static void main(String[] args) {
        Test12 t = new Test12();
        Thread thread1 = new Thread(t);
        Thread thread2 = new Thread(t);
        Thread thread3 = new Thread(t);
                                                          
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

执行效果和上面的同步线程完全一样。

当多个线程共享一个资源的时候需要进行同步，但是过多的同步可能导致死锁。

经典的生产者和消费者问题············To be continued...

本文出自 “阿凡达” 博客，请务必保留此出处http://shamrock.blog.51cto.com/2079212/1410738