多线程复习总结

最新推荐文章于 2021-06-16 21:58:47 发布

闹钟你别闹丿

最新推荐文章于 2021-06-16 21:58:47 发布

阅读量183

点赞数

文章标签：多线程 java锁

本文链接：https://blog.csdn.net/u011592040/article/details/97106964

版权

一、为什么有线程？

为了充分利用CPU资源，才有了进程和线程

进程

1.磁盘和CPU有速度差异，故I/O需要等待，因此产生出进程,可以让CPU在等待时可以处理其他事件。
程序：硬盘中的二进制文件；
进程：内存中的二进制文件；本质也就是PCB（进程控制块）；

线程

进程让操作系统的并发成为可能，线程让进程内部的并发成为了可能。

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。

线程和进程有什么区别？

线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据。

Java多线程实现的方式有四种

1.继承Thread类，重写run方法
2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target
3.通过Callable和FutureTask创建线程
4.通过线程池创建线程
方式1：继承Thread类的线程实现方式如下：

public class ThreadDemo01 extends Thread{
    public ThreadDemo01(){
        //编写子类的构造方法，可缺省
    }
    public void run(){
        //编写自己的线程代码
        System.out.println(Thread.currentThread().getName());
    }
    public static void main(String[] args){ 
        ThreadDemo01 threadDemo01 = new ThreadDemo01(); 
        threadDemo01.setName("我是自定义的线程1");
        threadDemo01.start();       
        System.out.println(Thread.currentThread().toString());  
    }
}

程序结果：
Thread[main,5,main]
我是自定义的线程1

线程实现方式2：通过实现Runnable接口，实现run方法，接口的实现类的实例作为Thread的target作为参数传入带参的Thread构造函数，通过调用start()方法启动线程

public class ThreadDemo02 {

    public static void main(String[] args){ 
        System.out.println(Thread.currentThread().getName());
        Thread t1 = new Thread(new MyThread());
        t1.start(); 
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+"-->我是通过实现接口的线程实现方式！");
    }   
}

程序运行结果：
main
Thread-0–>我是通过实现接口的线程实现方式！

线程实现方式3：通过Callable和FutureTask创建线程

a:创建Callable接口的实现类，并实现Call方法

b:创建Callable实现类的实现，使用FutureTask类包装Callable对象，该FutureTask对象封装Callable对象的Call方法的返回值

c:使用FutureTask对象作为Thread对象的target创建并启动线程

d:调用FutureTask对象的get()来获取子线程执行结束的返回值

public class ThreadDemo03 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Callable<Object> oneCallable = new Tickets<Object>();
        FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);

        Thread t = new Thread(oneTask);

        System.out.println(Thread.currentThread().getName());

        t.start();

    }

}

class Tickets<Object> implements Callable<Object>{

    //重写call方法
    @Override
    public Object call() throws Exception {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+"-->我是通过实现Callable接口通过FutureTask包装器来实现的线程");
        return null;
    }   
}

程序运行结果：
main
Thread-0–>我是通过实现Callable接口通过FutureTask包装器来实现的线程

线程实现方式4：通过线程池创建线程

public class ThreadDemo05{

    private static int POOL_NUM = 10;     //线程池数量

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        ExecutorService executorService = Executors.newFixedThreadPool(5);  
        for(int i = 0; i<POOL_NUM; i++)  
        {  
            RunnableThread thread = new RunnableThread();

            //Thread.sleep(1000);
            executorService.execute(thread);  
        }
        //关闭线程池
        executorService.shutdown(); 
    }   

}

class RunnableThread implements Runnable  
{     
    @Override
    public void run()  
    {  
        System.out.println("通过线程池方式创建的线程：" + Thread.currentThread().getName() + " ");  

    }  
}

程序运行结果：

通过线程池方式创建的线程：pool-1-thread-3

通过线程池方式创建的线程：pool-1-thread-4

通过线程池方式创建的线程：pool-1-thread-1

通过线程池方式创建的线程：pool-1-thread-5

通过线程池方式创建的线程：pool-1-thread-2

通过线程池方式创建的线程：pool-1-thread-5

通过线程池方式创建的线程：pool-1-thread-1

通过线程池方式创建的线程：pool-1-thread-4

通过线程池方式创建的线程：pool-1-thread-3

通过线程池方式创建的线程：pool-1-thread-2

二、Java线程状态

在这里插入图片描述

三、Java线程安全

多线程访问同一个上下文数据(存在与PCB中)，会造成线程安全
一个PCB包含多个TCB（线程控制块）
本质也就是多核CPU中高速缓存速度不一致。

在这里插入图片描述
解决：
1.加锁
2.共享缓存（第一代star，第二代bus，第三代mesh）

锁

Java中有各种种类丰富的锁，每种锁的特性不同，不同场景下能够展现出非常高的效率。Java中往往是按照是否含有某一特性来定义锁。

1.乐观锁vs悲观锁
要不要锁住同步资源
要：悲观锁 sychronized和Lock
总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

性能的区别：
在Synchronized优化以前，synchronized的性能是比ReenTrantLock差很多的，但是自从Synchronized引入了偏向锁，轻量级锁（自旋锁）后，导致在Java1.6上synchronize的性能并不比Lock差，在两种方法都可用的情况下，官方甚至建议使用synchronized，其实synchronized的优化我感觉就借鉴了ReenTrantLock中的CAS技术。都是试图在用户态就把加锁问题解决，避免进入内核态的线程阻塞。

不要：乐观锁 CAS算法（Compare and swap）
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

2.自旋锁vs适应性自旋锁
锁住同步资源失败，线程要不要阻塞
不阻塞：分两种情况
自旋锁（spinlock）：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待(JDK1.6以后默认开启了自旋锁，自旋的次数默认是10次) ，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。（与互斥锁不同，他不进入睡眠状态）

Java如何实现自旋锁？
简单的例子：

public class SpinLock {
    private AtomicReference<Thread> cas = new AtomicReference<Thread>();
    public void lock() {
        Thread current = Thread.currentThread();
        // 利用CAS
        while (!cas.compareAndSet(null, current)) {
            // DO nothing
        }
    }
    public void unlock() {
        Thread current = Thread.currentThread();
        cas.compareAndSet(current, null);
    }
}

lock（)方法利用的CAS，当第一个线程A获取锁的时候，能够成功获取到，不会进入while循环，如果此时线程A没有释放锁，另一个线程B又来获取锁，此时由于不满足CAS，所以就会进入while循环，不断判断是否满足CAS，直到A线程调用unlock方法释放了该锁。

自适应的自旋锁
JDK1.6中引入了自适应的自旋锁。自适应意味着自旋的时间不再是固定的，而是由前一次在同一个锁上的自旋时间以及锁拥有者的状态来决定。如果在同一个锁对象上, 自旋等待刚好成功获得锁，并且在持有锁的线程在运行中，那么虚拟机就会认为这次自旋也是很有可能获得锁，进而它将允许自旋等待相对更长的时间。

3.无锁vs偏向锁vs轻量级锁vs重量级锁**
多个线程竞争资源的细节区别(这四种状态都不是Java语言中的锁，而是Jvm为了提高锁的获取与释放效率而做的优化(使用synchronized时)。)
偏向锁
偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。
轻量级
轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。
重量级锁
重量级锁是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低。
4.公平锁vs非公平锁
多个线程竞争锁时要不要排队
公平锁
公平锁是指多个线程按照申请锁的顺序来获取锁。
非公平锁
非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿现象。
对于Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。
对于Synchronized而言，也是一种非公平锁。由于其并不像ReentrantLock是通过AQS的来实现线程调度，所以并没有任何办法使其变成公平锁。
5.可重入锁vs非可重入锁
一个线程中的多个流程能不能获取同一把锁
可重入锁
广义上的可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提得是同一个对象或者class），这样的锁就叫做可重入锁。ReentrantLock和synchronized都是可重入锁

synchronized void setA() throws Exception{
    Thread.sleep(1000);
    setB();
}
 
synchronized void setB() throws Exception{
    Thread.sleep(1000);
}

上面的代码就是一个可重入锁的一个特点，如果不是可重入锁的话，setB可能不会被当前线程执行，可能造成死锁。
不可重入锁
不可重入锁，与可重入锁相反，不可递归调用，递归调用就发生死锁。看到一个经典的讲解，使用自旋锁来模拟一个不可重入锁

import java.util.concurrent.atomic.AtomicReference;
 
public class UnreentrantLock {
 
    private AtomicReference<Thread> owner = new AtomicReference<Thread>();
 
    public void lock() {
        Thread current = Thread.currentThread();
        //这句是很经典的“自旋”语法，AtomicInteger中也有
        for (;;) {
            if (!owner.compareAndSet(null, current)) {
                return;
            }
        }
    }
 
    public void unlock() {
        Thread current = Thread.currentThread();
        owner.compareAndSet(current, null);
    }
}

代码也比较简单，使用原子引用来存放线程，同一线程两次调用lock()方法，如果不执行unlock()释放锁的话，第二次调用自旋的时候就会产生死锁，这个锁就不是可重入的，而实际上同一个线程不必每次都去释放锁再来获取锁，这样的调度切换是很耗资源的。
6.共享锁vs排他锁
多个线程能不能共享一把锁
独享锁：该锁每一次只能被一个线程所持有。
共享锁：该锁可被多个线程共有，典型的就是ReentrantReadWriteLock里的读锁，它的读锁是可以被共享的，但是它的写锁确每次只能被独占。
另外读锁的共享可保证并发读是非常高效的，但是读写和写写，写读都是互斥的。
对于Synchronized而言，当然是独享锁。

synchronized与Lock的区别

类别	synchronized	Lock
存在层次	Java的关键字，在jvm层面上	是一个类
锁的释放	1、以获取锁的线程执行完同步代码，释放锁 2、线程执行发生异常，jvm会让线程释放锁	在finally中必须释放锁，不然容易造成线程死锁-
锁的获取	假设A线程获得锁，B线程等待。如果A线程阻塞，B线程会一直等待	分情况而定，Lock有多个锁获取的方式，具体下面会说道，大致就是可以尝试获得锁，线程可以不用一直等待-
锁状态	无法判断	可以判断-
锁类型	可重入不可中断非公平	可重入可判断可公平（两者皆可）
性能	少量同步	大量同步-

闹钟你别闹丿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程复习总结

一、为什么有线程？为了充分利用CPU资源，才有了进程和线程进程1.磁盘和CPU有速度差异，故I/O需要等待，因此产生出进程,可以让CPU在等待时可以处理其他事件。程序：硬盘中的二进制文件；进程：内存中的二进制文件；本质也就是PCB（进程控制块）；线程进程让操作系统的并发成为可能，线程让进程内部的并发成为了可能。线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的...
复制链接

扫一扫