Java多线程

Java实现多线程有两种方法，一是继承Thread类，二是实现Runnable接口。

继承Thread类

继承Thread类，并重写Thread类中的run()方法。调用父类 Thread中start()方法启动线程。

继承Thread类实例：

public class Q {
    public static void main(String[] args) {
        //创建一个A类的实例对象
        A a = new A();
        //启动线程
        a.start();
        //main函数
        System.out.println("main method");
    }
}

class A extends Thread{
    public void run(){
        System.out.println("Hello World!");
    }
}

运行结果：
main method
Hello World!
表明两个线程运行完毕。

上面的例子使用了自定义的类继承Thread类来实现多线程，还有更简单的方式，先前不需要定义一个类继承Thread类，直接使用Thread类本身，并重写Thread类中的run()方法来实现多线程。实例如下：

public class Q {
    public static void main(String[] args) {
        //创建一个Thread类的实例，在创建时重写run()方法。
        Thread t = new Thread(){
            public void run(){
                System.out.println("Thread类的线程");
            }
        };
        t.start();
        System.out.println("main方法的线程");
    }
}

运行结果如下：
main方法的线程
Thread类的线程

实现Runnable接口

实现Runnable接口主要是为了解决单继承所带来的不便。

首先我们来看一下Thread类其中的一个构造方法：

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

显然，此构造方法接受Runnable类型的参数。所以，所有实现Runnable的类都可以作为参数传递给Thread类的构造方法中。实例如下：

public class Q {
    public static void main(String[] args) {
        //创建一个A类的实例
        A a = new A();
        //创建一个Thread类对象
        Thread t = new Thread(a);
        //开启线程
        t.start();
        System.out.println("main method");
    }
}

class A implements Runnable{
    public void run(){
        System.out.println("实现Runnable接口实现多线程");
    }
}

运行结果如下：
main method
实现Runnable接口实现多线程

当然，我们要活学活用，或许我们可以不用传入实现Runnable的类的实例，而是传入继承了Thread类的实例作为参数。Thread类本身已经实现了Runnable接口，所以Thread类的构造方法可以接收Thread类本身以及Thread类的子类、实现Runnable接口的类。我们可以通过一个继承了Thread类的类的实例来作为参数传递给Thread类的构造方法中。实例如下：

public class Q {
    public static void main(String[] args) {
        //创建一个A类的实例对象
        A a = new A();
        //创建一个Thread类的实例
        Thread t = new Thread(a);
        //启动线程
        a.start();
        //main函数
        System.out.println("main method");
    }
}

class A extends Thread{
    public void run(){
        System.out.println("Hello World!");
    }
}

运行结果：
main method
Hello World!

大家可以和通过A类的实例a直接启动线程的方式做一下比较，两种方式的效果完全相同。

还可以通过匿名内部类的方式实现多线程，注意，匿名内部类的类不是class的意思，是type的意思，意味着类和接口都可以作为匿名内部类。实例如下：

public class Q {
    public static void main(String[] args) {
        //创建一个Thread类对象，构造方法传入匿名的Runnable接口，必须重写Runnable接口的方法。
        Thread t = new Thread(new Runnable(){
            public void run(){
                System.out.println("Anonymous inner type");
            }
        });
        System.out.println("main method");
    }
}

synchronized关键字

synchorized修饰方法，称为同步方法；修饰代码块，称为同步代码块。

首先我们来看一个没有使用synchronized关键字的多线程程序：

public class Q {
    public static void main(String[] args) {
        //创建一个A对象
        A a = new A();
        //创建两个线程t1、t2，共享a对象，线程名字取不同
        Thread t1 = new Thread(a, "线程1");
        Thread t2 = new Thread(a, "线程2");
        t1.start();
        t2.start();
    }
}

class A implements Runnable{

    int num = 10;

    public void run(){
        while (num > 0) {
            System.out.println(Thread.currentThread().getName()+"，num = "+num);
            num--;
        }
    }
}

运行结果：
线程1，num = 10
线程2，num = 10
线程1，num = 9
线程2，num = 8
线程1，num = 7
线程2，num = 6
线程1，num = 5
线程2，num = 4
线程1，num = 3
线程2，num = 2
线程1，num = 1

线程t1、t2本身是共享一个对象的成员变量num的，但打印出两个线程都为10的状况，这就是没有使用synchronized关键字所出现的问题。

使用过后的状况（以synchronized同步代码块为例）：

public class Q {
    public static void main(String[] args) {
        //创建一个A对象
        A a = new A();
        //创建两个线程t1、t2，共享a对象，线程名字取不同
        Thread t1 = new Thread(a, "线程1");
        Thread t2 = new Thread(a, "线程2");
        t1.start();
        t2.start();
    }
}

class A implements Runnable{

    int num = 100;

    public void run(){
        while (true) {
            synchronized (this) {
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName()+"，num = "+num);
                    num--;
                } else {
                    break;
                }
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}