Java多线程初探

线程

在早年计算机是单线程的，同时只能执行一个程序，程序执行完后才能开始下一个程序，于是人们想要一个更加高效率的系统，于是开始尝试编写能够同时执行多个程序的系统，多线程就应运而生。
在早期的单核CPU下，多进程只是伪多进程，利用了时间块和优先级调度完成多线程任务，这就是UNIX系统的多线程原理，延续到了现在。

一、进程与线程

进程：

进程是指在内存中运行的应用程序，每个进程都有一块属于自己的内存空间。进程不依赖于线程而独立存在，一个进程中可以启动多个线程。

线程：

线程是指进程中的一个执行流程，一个进程中可以运行多个线程。线程总是属于某个进程，线程没有自己的虚拟地址空间，与进程内的其他线程一起共享分配给该进程的所有资源。

二、线程安全问题

线程安全是什么？

在操作系统中，进程之间的数据是隔离的。但是如果是一个进程里面的多个线程，线程之间是共享一个进程的数据的。
在Java中，如果使用多个Thread启动同一个Runnable的线程对象，此时这些线程会共享Runnable对象中的属性，就容易出现线程安全问题（非线程安全问题）

public class Test1 {

    public static void main(String[] args) {
        MyThread05 mt1 = new MyThread05();
        MyThread05 mt2 = new MyThread05();
        mt1.start();
        mt2.start();
    }
}

class MyThread05 extends Thread {

    private static int id;

    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            id++;
        }
        System.out.println(this.currentThread().getName() + 
        "--结果是："+ id);
    }
}

当多个线程同时共享访问同一数据时，每个线程都尝试操作该数据，从而导致数据被破坏。

三、怎么解决线程安全问题？

JDK给我们提供了解决线程安全的办法——上锁

上锁有两种方式

1、synchronized关键字

synchronized关键字的使用:
(1) 语句块
synchronized(对象) {
需要加锁的代码
}

 public void run() {
        for (int i = 0; i < 1000000; i++) {
            synchronized (key) {
                id++;
            }
        }
        System.out.println(Thread.currentThread().getName() + "--结果是："+ id);
    }

(2) 修饰方法

@Override
    public synchronized void run() {
        for (int i = 0; i < 100000; i++) {
            id++;
        }
        System.out.println(this.currentThread().getName() + "--结果是："+ id);
    }

2、Lock接口

Lock接口需要使用它的子类ReentrantLock来实现上锁，并且Lock需要进行解锁操作
所以需要使用try/finally语句

 Lock lock = new ReentrantLock();
 @Override
    public void run() {
            for (int i = 0; i < 1000000; i++) {
                try {
                    // 加锁
                    lock.lock();
                    id++;
                } finally {
                    // 释放锁
                    lock.unlock();
                }
            }

        System.out.println(Thread.currentThread().getName() + "--结果是："+ id);
    }

四、synchronized和Lock的区别

相同处：

synchronized和Lock都是针对线程安全问题的，两者都是对线程进行上锁操作来实现线程安全的。

不同处：

1、synchronized是一个关键字，它可以用来修饰方法，也可以写语句块来上锁，而Lock是一个接口，它是通过子类实现进行上锁；

2、synchronized是JDK1.0提供，Oracle公司在收购sun公司后对这个方法进行了大量改动，使其要优于JDK1.5提供的Lock接口；

3、synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象的发生；而Lock在发生异常时，如果没有主动通过unlock()去释放锁，则很有可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

4、Lock可以让等待锁的线程相应中断；而synchronized不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

五、线程的生命周期及转换问题

1、什么是线程的生命周期？

Java 语言中线程共有五种状态，分别是：

1. NEW（创建线程）
2. READY（就绪状态）
3. RUNNABLE（运行状态）
4. BLOCKED（阻塞状态）
5. DESTROY（运行结束，销毁线程）

创建线程后调用start方法进入就绪状态，若被系统选择，则进入运行状态，如果调用Thread.yield方法，则重新进入就绪状态且当前线程运行完成后必进入运行状态。运行中如果调用Thread.sleep方法，则进入阻塞状态，当sleep结束或者另一线程终止，则进入就绪状态。run方法或者main方法结束，进入终止状态并销毁线程。

六、volatile关键字

1、保证内存可见性

基本概念

可见性是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果，另一个线程马上就能看到。当一个线程对某个变量进行修改之后，其他线程会调用修改后的变量的值。

2、禁止指令重排

基本概念

指令重排序是JVM为了优化指令、提高程序运行效率，在不影响单线程程序执行结果的前提下，尽可能地提高并行度。指令重排序包括编译器重排序和运行时重排序。

在JDK1.5之后，可以使用volatile变量禁止指令重排序。针对volatile修饰的变量，在读写操作指令前后会插入内存屏障，指令重排序时不能把后面的指令重排序到内存屏