Java多线程学习笔记

Java多线程学习笔记

1、继承Thread类

实现多线程的常用方法就是继承Thread类，然后覆盖run()方法。下面是一个通过继承Thread类实现多线程的小例子：

import java.util.Date;

public class ThreadTest extends Thread{

    @Override
    public void run() { // 重写run方法
        System.out.println(this.getName() + " " + new Date().toString());
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadTest t1 = new ThreadTest();
        t1.start();
        ThreadTest t2 = new ThreadTest();
        t2.start();
    }
}

运行结果如下：

Thread类实际上是Runnable接口的实现，

public class Thread implements Runnable {
    ...
}

Thread类中，有一些方法比较常用：

1. 线程在创建后，需要调用start()才能运行，然后线程会自动调用run()方法，所以在子类中需要覆盖run()方法。注意，我们要用start()来启动线程，run()方法仅仅是一个普通的方法。

2. sleep()和suspend()都可以让线程暂停执行，但是二者的区别如下：
   (1).sleep()使线程休眠后，只能在时间结束后，线程才能恢复到就绪状态；而suspend()挂起线程后，可以通过resume()唤醒线程。
   (2).另外，sleep()仅对当前线程起作用，而suspend()可以挂起另一个线程。

3. yield()是一个静态的native方法，它的作用是“告诉当前正在执行的线程，把运行机会交给线程池中拥有相同优先级的线程”，说白了就是把机会留给别人。

4. stop()和interrupt()都可以中断线程，但二者区别在于stop强制终止线程，而interrupt()中断线程。关于二者的具体介绍，详见：http://blog.csdn.net/wxwzy738/article/details/8516253。这里插一句，如果我们要中断线程，最好设置一个共享变量，然后在run方法中，周期性地检查该变量的值，满足终止条件时再终止线程。

为了加深理解，现附上线程生命周期图（图片来自百度百科）：

2、实现Runnable接口

Runnable接口的源码如下，只有一个抽象方法run()，因此实现这个接口的核心就是覆盖run()方法。

public interface Runnable {
    public abstract void run();
}

下面是一个小例子，这个例子实现了Runnable接口

import java.util.Date;

public class ThreadTest implements Runnable{

    String name;

    ThreadTest(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(this.name + " " + new Date().toString());
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadTest t1 = new ThreadTest("Thread1");
        new Thread(t1).start();
        ThreadTest t2 = new ThreadTest("Thread2");
        new Thread(t2).start();
    }

}

运行结果如下：

3、join方法

无join()时，主线程调用start()后，程序立即返回到主线程，此时主线程和子线程各运行各的，也就是我们常说的“异步”。

有join()时，主线程调用start()后，会一直等待子线程执行完毕，再往下执行，这也就是“同步”。

下面看两个小例子：

import java.util.Date;

public class ThreadTest extends Thread{

    @Override
    public void run() {
        while(true){
            try {
                this.sleep(1000);
                System.out.println(this.getName() + " " + new Date().toString());
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }   
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadTest t1 = new ThreadTest();
        t1.start();        
        ThreadTest t2 = new ThreadTest();
        t2.start();

        // 没有join() 直接返回到主线程
        System.out.println("t1,t2 stop");
    }

}

运行结果显示，主线程在启动t1、t2两个子线程后，直接返回到主线程继续执行 System.out.println(“t1,t2
stop”);

下面我们加上join()方法，同时把while去掉，避免程序进入死循环无法返回。

import java.util.Date;

public class ThreadTest extends Thread{

    @Override
    public void run() {
        // 去掉了while(true)的循环
        try {
            this.sleep(1000);
            System.out.println(this.getName() + " " + new Date().toString());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }   
    }

    public static void main(String[] args) throws InterruptedException { // 注意要抛出异常
        // TODO Auto-generated method stub
        ThreadTest t1 = new ThreadTest();
        t1.start();        
        ThreadTest t2 = new ThreadTest();
        t2.start();
        t1.join(); // t1添加join()
        t2.join(); // t2添加join()
        System.out.println("t1,t2 stop");
    }

}

来看看效果吧，可以看到，程序直到t1、t2线程结束后，才返回执行System.out.println(“t1,t2 stop”);

4、synchronized关键字

synchronized知识点总结：

1、synchronized可以修饰代码块、对象和方法，不能用于修饰int、char、boolean等简单类型的变量。

synchronized int a = 0; // 错误，synchronized 不能修饰int类型变量

2、synchronized不能被继承。若父类中有一个方法使用了synchronized修饰，子类中覆盖了这个方法，子类中的这个方法默认不是同步的，必须加synchronized关键词显示地生命同步。

3、synchronized不能放在返回类型后面，比如下面这句代码就是错误的。

void synchronized func() // 错的，synchronized不能放在返回值后面

synchronized关键字可以修饰代码块：

class Test {
    private final static String key = ""; // 注意要设置为final

    synchronized(key) {
        // TODO 这里是同步的代码块
        // 注意，这里不能改变key的值，否则不能同步
        // 因此要把key设置为final
    }
}

synchronized关键字也可以用来修饰方法，请看下面的例子：在单件模式中使用synchronized关键字。

5、用synchronized关键字实现单件模式

class Singleton {
    private static Singleton instance;
    private Singleton() {
    }

    // 使用synchronized 关键字修饰方法
    public static synchronized Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

当然，单件模式还有更简单的实现方式：

public class Singleton {
    private final static Singleton instance = new Singleton(); // 使用“急切”
    private Singleton() {
    }
    public static Singleton getInstance() {
         return instance;
    }

}

6、实例：使用多线程打印数字

public class ThreadTest implements Runnable {

    private int num = 0;

    @Override
    public synchronized void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println(this.num);
            num++;
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadTest t1 = new ThreadTest();
        new Thread(t1).start(); // 打印0-9
        new Thread(t1).start(); // 打印10-19
        new Thread(t1).start(); // 打印20-29
    }

}

程序的运行结果如下：

今天就到这里，拜~