Java 多线程技能

Java 多线程

进程和线程

进程

操作系统管理的基本运行单元。

线程

进程中独立运行的子任务。单任务的特点是排队执行（同步），CPU利用率低；多线程技术即为异步，系统的运行效率大大提升。

QQ可以理解为一个进程，其中包括很多线程：

1. 好友视频线程
2. 下载文件线程
3. 传输数据线程

使用多线程

继承Thread类

简单例子：

public class MyThread extends Thread{
    @Override
    public void run() {
        super.run();
        System.out.println("MyThread");
    }
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println("运行结束！");
    }
}

Thread类的定义：

public class Thread implements Runnable {

实现Runnable接口

因为Java不支持多继承，如果欲创建的线程类已经有一个父类，则不能直接继承Thread类。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("运行中");
    }
    public static void main(String[] args) {
        Runnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
        System.out.println("运行结束");
    }
}

实例变量和线程安全

自定义线程的实例变量，针对其他线程可以有共享与非共享之分。

不共享数据

public class MyThread extends Thread {
    private int count = 5;
    public MyThread(String name) {
        super();
        this.setName(name);
    }
    @Override
    public void run() {
        super.run();
        while (count > 0) {
            count--;
            System.out.println(this.currentThread().getName() + "计算，count=" + count);
        }
    }
    public static void main(String[] args) {
        MyThread a = new MyThread("A");
        MyThread b = new MyThread("B");
        MyThread c = new MyThread("C");
        a.start();
        b.start();
        c.start();
    }
}

运行结果：

A计算，count=4
B计算，count=4
A计算，count=3
B计算，count=3
B计算，count=2
B计算，count=1
B计算，count=0
A计算，count=2
A计算，count=1
C计算，count=4
C计算，count=3
C计算，count=2
C计算，count=1
C计算，count=0
A计算，count=0

共享数据

public class MyThread extends Thread {
    private int count = 5;
    @Override
    public void run() {
        count--;
        System.out.println(this.currentThread().getName() + "计算，count=" + count);
    }
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread a = new Thread(myThread, "A");
        Thread b = new Thread(myThread, "B");
        Thread c = new Thread(myThread, "C");
        Thread d = new Thread(myThread, "D");
        Thread e = new Thread(myThread, "E");
        a.start();
        b.start();
        c.start();
        d.start();
        e.start();
    }
}

运行结果：不保证顺序

D计算，count=1
B计算，count=3
A计算，count=3
C计算，count=2
E计算，count=0

某些JVM中，i--的操作要分成3步：

1. 取得原有i值
2. 计算i-1
3. 对i进行赋值

如果有多个线程同时访问，那么会出现非线程安全问题。

多个线程间进行同步，加锁-synchronized：

    @Override
    synchronized public void run() {
        count--;
        System.out.println(this.currentThread().getName() + "计算，count=" + count);
    }

结果：

B计算，count=4
A计算，count=3
D计算，count=2
E计算，count=1
C计算，count=0

通过在run方法前加入synchronized关键字，使多个线程在执行run方法时，以排队的方式进行处理。当一个线程调用run前，先判断run方法有没有被上锁。如果上锁，则表明其它线程在调用run方法，必须等其它线程对run方法调用结束后才可以执行run方法。加锁的代码称为互斥区或临界区。

守护线程

一种特殊的线程，特性有陪伴的含义，当进程中没有非守护线程了，守护线程会自动销毁。

典型的守护线程就是GC-垃圾回收线程。