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修饰的变量,在读写操作指令前后会插入内存屏障,指令重排序时不能把后面的指令重排序到内存屏

©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页