Java并发编程(一)——进程和线程、Java对象内存布局、synchronized、wait和notify、park和unpack

时间:2021-08-29 21:53:38   收藏:0   阅读:14

一、进程和线程

进程和线程的区别?

进程:进程是程序的一次执行过程。是CPU资源分配的最小单位。每个进程都有自己独立的一块内存空间,一个进程可以有多个线程

线程:线程是CPU调度的最小单位,它可以和属于同一个进程的其他线程共享这个进程的全部资源

进程和线程的区别

从 JVM 角度说进程和线程之间的关系:

待补:

并行和并发有什么区别?

二、Java线程

2.1 创建线程的四种方式

  1. 创建继承于Thread类的子类,并重写Thread类的run()方法

  2. 创建一个实现了Runnable接口的类,并实现run()方法

  3. 通过Callable和FutureTask创建线程

    1. 创建一个实现Callable的实现类,并实现call方法
    2. 将Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象
    3. 将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
    4. 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
    @Test
    public void test03() throws ExecutionException, InterruptedException {
        // 实现多线程的第三种方法可以返回数据
        FutureTask futureTask = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                log.debug("多线程任务");
                Thread.sleep(100);
                return 100;
            }
        });
        // 主线程阻塞,同步等待 task 执行完毕的结果
        new Thread(futureTask,"分线程").start();
        log.debug("主线程");
        log.debug("{}",futureTask.get()); //获得分线程的返回值,get方法为阻塞方法
        
    }
    
  4. 使用线程池

    class NumberThread implements Runnable{
        @Override
        public void run() {
            for(int i = 0;i<10;i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
    
    class Number2Thread implements Callable {
        @Override
        public Object call() throws Exception {
            int sum = 0;
            for(int i = 1;i<=10;i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
                sum+=i;
            }
            return sum;
        }
    }
    
    public class ThreadPool {
        public static void main(String[] args) {
            //1. 提供指定线程数量的线程池
            ExecutorService service = Executors.newFixedThreadPool(10);//创建一个可重用固定线程数为10的线程池
    
            //查看该对象是哪个类造的
            System.out.println(service.getClass());//class java.util.concurrent.ThreadPoolExecutor
            //设置线程池的属性
    //        service1.setCorePoolSize(15);
    //        service1.setKeepAliveTime();
    
            //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
            service.execute(new NumberThread());//适合使用于Runnable
            Future future = service.submit(new Number2Thread());//适合使用于Callable
            try {
                System.out.println(future.get());//输出返回值
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
            //3.关闭连接池
            service.shutdown();
        }
    }
    

runnable 和 callable 有什么区别?

线程的 run()和 start()有什么区别?

2.2 线程的生命周期

技术分享图片

  1. 新建(new):新创建了一个线程对象。

  2. 就绪(runnable):线程对象创建后,当调用线程对象的 start()方法,该线程处于就绪状态,等待被线程调度选中,获取cpu的使用权。

  3. 运行(running):可运行状态(runnable)的线程获得了cpu时间片(timeslice),执行程序代码。注:就绪状态是进入到运行状态的唯一入口,也就是说,线程要想进入运行状态执行,首先必须处于就绪状态中;

  4. 阻塞(block):处于运行状态中的线程由于某种原因,暂时放弃对 CPU的使用权,停止执行,此时进入阻塞状态,直到其进入到就绪状态,才有机会再次被 CPU 调用以进入到运行状态。

    阻塞的情况分三种:

    1. 等待阻塞:运行状态中的线程执行 wait()方法,JVM会把该线程放入等待队列(waitting queue)中,使本线程进入到等待阻塞状态;
    2. 同步阻塞:线程在获取 synchronized 同步锁失败(因为锁被其它线程所占用),,则JVM会把该线程放入锁池(lock pool)中,线程会进入同步阻塞状态;
    3. 其他阻塞: 通过调用线程的 sleep()或 join()或发出了 I/O 请求时,线程会进入到阻塞状态。当 sleep()状态超时、join()等待线程终止或者超时、或者 I/O 处理完毕时,线程重新转入就绪状态。
  5. 死亡(dead):线程run()、main()方法执行结束,或者因异常退出了run()方法,则该线程结束生命周期。死亡的线程不可再次复生。

线程的六种状态:

技术分享图片

2.3 线程的状态转换(API层次)

技术分享图片

假设有线程 Thread t

技术分享图片

2.4 线程运行原理

虚拟机栈与栈帧

线程上下文切换(Thread Context Switch)

因为以下一些原因导致 cpu 不再执行当前的线程,转而执行另一个线程的代码

当Thread Context Switch发生时,需要由操作系统保存当前线程的状态,并恢复另一个线程的状态,Java 中对应的概念就是程序计数器(Program Counter Register),它的作用是记住下一条 jvm 指令的执行地址,是线程私有的

2.5 守护线程

注意:

  • 垃圾回收器线程就是一种守护线程
  • Tomcat 中的 Acceptor 和 Poller 线程都是守护线程,所以 Tomcat 接收到 shutdown 命令后,不会等

三、Java对象内存布局和对象头

在 JVM 中,Java对象保存在堆中时,由以下三部分组成:

即:对象示例 = 对象头 + 实例数据 + 对齐填充


对象头分为两类信息:一类是Mark Word用(于存储对象自身的运行时数据),一类是Klass Point(类型指针)。

即:对象头 = 对象标记markword + 类型指针

即:对象在堆内存中的整体结构布局

技术分享图片

Mark Word:

Mark Word在不同的锁状态下存储的内容不同。

在32位JVM中是这么存的(了解)

技术分享图片

在64位JVM中的存储结构:

技术分享图片

虽然它们在不同位数的JVM中长度不一样,但是基本组成内容是一致的。

代码示例证明对象头:(借助JOL工具)

  1. 查看new一个Object对象的对象头

    技术分享图片

    字段 说明
    OFFSET 偏移量,也就是到这个字段位置所占用的byte数
    SIZE 后面类型的字节大小
    TYPE 是Class中定义的类型
    DESCRIPTION DESCRIPTION是类型的描述
    VALUE VALUE是TYPE在内存中的值

    可以看到这里mark word占8byte(64bit),klass pointe 占4byte,另外剩余4byte是填充对齐的,

    这是由于默认开启了指针压缩 ,klass pointe 占4byte(默认其实是占用8byte)

  2. 关闭指针压缩后,查看new一个Object对象的对象头。

    jdk8版本是默认开启指针压缩的,可以通过配置jvm参数开启关闭指针压缩,-XX:-UseCompressedOops。

    技术分享图片

    如果关闭指针压缩重新打印对象的内存布局,可以发现总SIZE变大了,从下图中可以看到,对象头所占用的内存大小变为16byte(128bit),其中 mark word占8byte,klass pointe 占8byte,无对齐填充。

一般而言64位JDK8按照默认情况下,new一个对象占多少内存空间?

以下面的对象为例:其中int占4个字节,char占1个字节。

class MyObject{
    int i = 5;
    char a = ‘a‘;
}

所以是 8(对象头)+ 8(类型指针,关闭指针压缩的情况) + 5 + 3(类型填充) = 24字节(虚拟机要求对象起始地址必须是8字节的整数倍。)

好的博客:Java对象的内存布局

四、synchronized与锁升级

4.1 synchronized关键字

方法上的 synchronized

**private 或 final的重要性: **提高线程的安全性

总结:

4.2 synchronized的锁升级

4.2.1 偏向锁

为什么要引入偏向锁?

偏向锁的升级:

偏向锁相关jvm参数:

代码测试:

相关了解

4.2.2 轻量级锁

轻量级锁的本质就是自旋锁

为什么要引入轻量级锁?


轻量锁的升级时机 : 当关闭偏向锁功能或多线程竞争偏向锁会导致偏向锁升级为轻量级锁


轻量级锁什么时候升级为重量级锁?


自适应自旋锁

4.2.2.1 轻量级锁流程解释

轻量级锁加锁流程:

  1. 在获取轻量锁是会创建锁记录(Lock Record)对象,每个线程的栈帧都会包含一个锁记录的结构,内部可以存储锁定对象的Mark Word。

    技术分享图片

  2. 让锁记录中的Object reference指向锁对象地址,并且尝试用CAS将栈帧中的锁记录的(lock record 地址 00)替换Object对象的Mark Word,将Mark Word 的值(01)存入锁记录(lock record地址)------相互替换

    • 01 表示 无锁 (看Mark Word结构, 数字的含义)
    • 00 表示 轻量级锁

    技术分享图片

  3. 如果cas替换成功, 获得了轻量级锁,那么对象的对象头储存的就是锁记录的地址和状态00。线程中锁记录, 记录了锁对象的锁状态标志; 锁对象的对象头中存储了锁记录的地址和状态, 标志哪个线程获得了锁
    技术分享图片

  4. 如果cas替换失败,有两种情况 : ① 锁膨胀 ② 执行了锁重入

    • 如果是其它线程已经持有了该Object的轻量级锁,那么表示有竞争,自旋一定的时间后,将进入锁膨胀阶段(膨胀我重量级锁)。

    • 如果是自己的线程已经执行了synchronized进行加锁,那么再添加一条 Lock Record 作为重入锁的计数 – 线程多次加锁, 锁重入。
      技术分享图片

      技术分享图片


轻量级锁解锁流程:


轻量级锁膨胀流程:

4.2.3 Monitor 原理 (重量级锁原理)

Monitor也称为监视器或者管程

每个Java对象都可以关联一个(操作系统的)Monitor,如果使用synchronized给对象上锁(重量级),该对象头的MarkWord中就被设置为指向Monitor对象的指针

下图原理解释:

  • 当Thread2访问到synchronized(obj)中的共享资源的时候

    • 首先会将synchronized中的锁对象中对象头的MarkWord去尝试指向操作系统的Monitor对象. 让锁对象中的MarkWord和Monitor对象相关联. 如果关联成功, 将obj对象头中的MarkWord为指向重量级锁的指针,并且标志位变为10。

      技术分享图片

    • 因为Monitor没有和其他的obj的MarkWord相关联, 所以Thread2就成为了该Monitor的Owner(所有者)。

    • 又来了个Thread1执行synchronized(obj)代码, 它首先会看看能不能执行该临界区的代码; 它会检查obj是否关联了Montior, 此时已经有关联了, 它就会去看看该Montior有没有所有者(Owner), 发现有所有者了(Thread2); Thread1也会和该Monitor关联, 该线程就会进入到它的EntryList(阻塞队列);

    • 当Thread2执行完临界区代码后, Monitor的Owner(所有者)就空出来了. 此时就会通知Monitor中的EntryList阻塞队列中的线程, 这些线程通过竞争, 成为新的所有者
      技术分享图片

总结:

技术分享图片

注意:它加锁就是依赖底层操作系统的 mutex相关指令实现, 所以会造成用户态和内核态之间的切换, 非常耗性能 !

  • 在JDK6的时候, 对synchronized进行了优化, 引入了轻量级锁, 偏向锁, 它们是在JVM的层面上进行加锁逻辑, 就没有了切换的消耗

分析synchronized的字节码

Synchronized代码块同步在需要同步的代码块开始的位置插入monitorenter指令,在同步结束的位置或者异常出现的位置插入monitorexit指令;JVM要保证monitorenter和monitorexit都是成对出现的,任何对象都有一个monitor与之对应,当这个对象的monitor被持有以后,它将处于锁定状态。

static final Object lock = new Object();
static int counter = 0;
public static void main(String[] args) {
    synchronized (lock) {
        counter++;
    }
}

对应的字节码为:

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC 
    Code:
        stack=2, locals=3, args_size=1
            0: getstatic #2 	// <- lock引用 (synchronized开始)
            3: dup
            4: astore_1 		// lock引用 -> slot 1
            5: monitorenter 	// 将 lock对象 MarkWord 置为 Monitor 指针
            6: getstatic #3 	// <- i ,6-14行即为i++操作
            9: iconst_1 		// 准备常数 1
            10: iadd 			// +1
            11: putstatic #3 	// -> i
            14: aload_1 		// <- lock引用
            15: monitorexit 	// 将 lock对象 MarkWord 重置, 唤醒 EntryList
            16: goto 24
            19: astore_2 		// e -> slot 2
            20: aload_1 		// <- lock引用
            21: monitorexit 	// 将 lock对象 MarkWord 重置, 唤醒 EntryList
            22: aload_2 		// <- slot 2 (e)
            23: athrow 			// throw e
            24: return
        Exception table:
        from to target type
        6 16 19 any     //如果6-16行出现异常则转到19行,如果出现异常也可以释放锁
        19 22 19 any

当执行 monitorenter 指令时,线程试图获取锁也就是获取 对象监视器 monitor 的持有权。

在执行monitorenter时,会尝试获取对象的锁,如果锁的计数器为 0 则表示锁可以被获取,获取后将锁计数器设为 1 也就是加 1。

在执行 monitorexit 指令后,将锁计数器设为 0,表明锁被释放。如果获取对象锁失败,那当前线程就要阻塞等待,直到锁被另外一个线程释放为止。

4.2.4 锁消除和锁粗化

锁消除

锁粗化

4.2.5 总结

这几种锁的优缺点:

锁 优点 缺点 适用场景
偏向锁 加锁和解锁不需要额外的消耗,和执行非同步方法比仅存在纳秒级的差距。 如果线程间存在锁竞争,会带来额外的锁撤销的消耗。 适用于基本没有线程竞争锁的同步场景。
轻量级锁 竞争的线程不会阻塞,提高了程序的响应速度。 如果始终得不到锁竞争的线程使用自旋会消耗CPU。 适用于少量线程竞争锁对象,且线程持有锁的时间不长,追求响应速度的场景。
重量级锁 线程竞争不使用自旋,不会消耗CPU。 线程阻塞,响应时间缓慢。 很多线程竞争锁,同步块执行时间较长。追求吞吐量的场景。

锁升级的流程图:

技术分享图片

synchronized 锁升级原理:

好的博客:

深入分析Synchronized原理(阿里面试题

Java并发——Synchronized关键字和锁升级,详细分析偏向锁和轻量级锁的升级

Java并发编程(三) : synchronized底层原理、优化Monitor重量级锁、轻量级锁、自旋锁(优化重量级锁竞争)、偏向锁

五、wait和notify

wait、notify原理


API介绍:

下面的四个方法都是Object中的方法; 通过锁对象来调用

注意:它们都是线程之间进行协作的手段, 都属于Object对象的方法, 必须获得此对象的锁, 才能调用这些方法

public class Test1 {	final static Object LOCK = new Object();	public static void main(String[] args) throws InterruptedException {        //只有在对象被锁住后才能调用wait方法		synchronized (LOCK) {			LOCK.wait();		}	}}

wait()使用注意:防止出现虚假唤醒机制


sleep() 和 wait() 有什么区别?

相同点:

不同点:

5.1 消费者、生产者模式

@Slf4j(topic = "c.Test21")public class TestConsume {    public static void main(String[] args) {        MessageQueue queue = new MessageQueue(2);        for (int i = 0; i < 3; i++) {            int id = i;            new Thread(() -> {                queue.put(new Message(id , "值"+id));            }, "生产者" + i).start();        }        new Thread(() -> {            while(true) {                try {                    Thread.sleep(1000);                } catch (InterruptedException e) {                    e.printStackTrace();                }                Message message = queue.take();            }        }, "消费者").start();    }}// 消息队列类 , java 线程之间通信@Slf4j(topic = "c.MessageQueue")class MessageQueue {    // 消息的队列集合    private LinkedList<Message> list = new LinkedList<>();    // 队列容量    private int capcity;    public MessageQueue(int capcity) {        this.capcity = capcity;    }    // 获取消息    public Message take() {        // 检查队列是否为空        synchronized (list) {            while(list.isEmpty()) {                try {                    log.debug("队列为空, 消费者线程等待");                    list.wait();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }            // 从队列头部获取消息并返回            Message message = list.removeFirst();            log.debug("已消费消息 {}", message);            list.notifyAll();            return message;        }    }    // 存入消息    public void put(Message message) {        synchronized (list) {            // 检查对象是否已满            while(list.size() == capcity) {                try {                    log.debug("队列已满, 生产者线程等待");                    list.wait();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }            // 将消息加入队列尾部            list.addLast(message);            log.debug("已生产消息 {}", message);            list.notifyAll();        }    }}final class Message {    private int id;    private Object value;    public Message(int id, Object value) {        this.id = id;        this.value = value;    }    public int getId() {        return id;    }    public Object getValue() {        return value;    }    @Override    public String toString() {        return "Message{" +                "id=" + id +                ", value=" + value +                ‘}‘;    }}

执行结果:

技术分享图片

六、LockSupport之park、unpack

注意:先调用unpark后,再调用park, 此时park不会暂停线程

@slf4jpublic class Test {    public static void main(String[] args) {        Thread t1 = new Thread(() -> {            log.debug("start...");            sleep(2);            log.debug("park...");            LockSupport.park();            log.debug("resume...");        }, "t1");        t1.start();        sleep(1);        log.debug("unpark...");        LockSupport.unpark(t1);    }}

输出:

18:43:50.765 c.TestParkUnpark [t1] - start... 18:43:51.764 c.TestParkUnpark [main] - unpark... 18:43:52.769 c.TestParkUnpark [t1] - park... 18:43:52.769 c.TestParkUnpark [t1] - resume...

与Object的wait&notify区别


park、unpark 原理:

原文:https://www.cnblogs.com/jobim/p/15200665.html

评论(0)
© 2014 bubuko.com 版权所有 - 联系我们:wmxa8@hotmail.com
打开技术之扣,分享程序人生!