Java JUC学习笔记 day01

最新推荐文章于 2024-02-21 16:11:44 发布

Aluem

最新推荐文章于 2024-02-21 16:11:44 发布

阅读量316

点赞数

分类专栏： JavaSE JUC

本文链接：https://blog.csdn.net/Alu_em/article/details/108563998

版权

JavaSE 同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

JUC

1 篇文章 0 订阅

订阅专栏

文章目录

Java JUC学习笔记

Java JUC学习笔记

1. Java JUC 简介

在 Java 5.0 提供了 java.util.concurrent （简称JUC ）包，在此包中增加了在并发编程中很常用
的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步 IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的 Collection 实现等。

2. volatile 关键字-内存可见性

2.1 内存可见性

内存可见性（Memory Visibility）是指当某个线程正在使用对象状态而另一个线程在同时修改该状态，需要确保当一个线程修改了对象状态后，其他线程能够看到发生的状态变化。
可见性错误是指当读操作与写操作在不同的线程中执行时，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。
我们可以通过同步来保证对象被安全地发布。除此之外我们也可以使用一种更加轻量级的 volatile 变量。

2.1.1 示例

package com.atguigu.juc;

/**
 * 一、volatile 关键字：
 */
public class TestVolatile {
    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();
        new Thread(td).start();

        while (true) {
            if (td.isFlag()) {
                System.out.println("---------------");
                break;
            }
        }
        
    }
}

class ThreadDemo implements Runnable {

    private boolean flag = false;

    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        flag = true;

        System.out.println("flag=" + flag);

    }

    public boolean isFlag() {
        return  flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

运行结果：
在这里插入图片描述

问题：当子线程将flag修改为true以后，主线程的“-------------”依旧没有打印，即主线程的flag仍为false

产生问题的原因

线程1在main线程读取后才将flag修改为true，然后将数据更新到主存中，但由于main线程中执行while(true)循环速度极快，从而无法从主存中获取更新flag的数据，而导致main线程进入死循环。

2.2 volatile 关键字

Java 提供了一种稍弱的同步机制，即 volatile 变量，用来确保将变量的更新操作通知到其他线程。可以将 volatile 看做一个轻量级的锁，但是又与锁有些不同：
- 对于多线程，不是一种互斥关系
- 不能保证变量状态的“原子性操作”

在这里插入图片描述

3. 原子变量-CAS算法

3.1 CAS 算法

CAS (Compare-And-Swap) 是一种硬件对并发的支持，针对多处理器操作而设计的处理器中的一种特殊指令，用于管理对共享数据的并发访问。
CAS 是一种无锁的非阻塞算法的实现。
CAS 包含了 3 个操作数：
- 需要读写的内存值 V
- 进行比较的值 A
- 拟写入的新值 B
当且仅当 V 的值等于 A 时，CAS 通过原子方式用新值 B 来更新 V 的值，否则不会执行任何操作。

3.2 原子变量

类的小工具包，支持在单个变量上解除锁的线程安全编程。事实上，此包中的类可
将 volatile 值、字段和数组元素的概念扩展到那些也提供原子条件更新操作的类。
类 AtomicBoolean、AtomicInteger、AtomicLong 和 AtomicReference 的实例各自提供对
相应类型单个变量的访问和更新。每个类也为该类型提供适当的实用工具方法。
AtomicIntegerArray、AtomicLongArray 和 AtomicReferenceArray 类进一步扩展了原子操
作，对这些类型的数组提供了支持。这些类在为其数组元素提供 volatile 访问语义方
面也引人注目，这对于普通数组来说是不受支持的。
核心方法：boolean compareAndSet(expectedValue, updateValue)
java.util.concurrent.atomic 包下提供了一些原子操作的常用类:
- AtomicBoolean 、AtomicInteger 、AtomicLong 、 AtomicReference
- AtomicIntegerArray 、AtomicLongArray
- AtomicMarkableReference
- AtomicReferenceArray
- AtomicStampedReference

3.3 原子性问题示例

package com.atguigu.juc;

public class TestAtomicDemo {

    public static void main(String[] args) {
        AtomicDemo ad = new AtomicDemo();

        for (int i = 0; i < 10; i++) {
            new Thread(ad).start();
        }
    }
}

class AtomicDemo implements Runnable {

    private int serialNumber = 0;

    @Override
    public void run() {

        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + ":" + getSerialNumber());
    }

    public int getSerialNumber() {
        return serialNumber++;
    }
}

在这里插入图片描述

运行结果出现重复数据

出现问题原因：

在线程1修改了sn后还未写入主存时，线程2也读取到原来的sn，因此会打印两个同样的值

3.4 使用CAS解决问题

在这里插入图片描述

package com.atguigu.juc;

import java.util.concurrent.atomic.AtomicInteger;

public class TestAtomicDemo {

    public static void main(String[] args) {
        AtomicDemo ad = new AtomicDemo();

        for (int i = 0; i < 10; i++) {
            new Thread(ad).start();
        }
    }
}

class AtomicDemo implements Runnable {

//    private int serialNumber = 0;
    private AtomicInteger serialNumber = new AtomicInteger();

    @Override
    public void run() {

        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + ":" + getSerialNumber());
    }

    public int getSerialNumber() {
        return serialNumber.getAndIncrement();
    }
}

3.5 模拟CAS算法

package com.atguigu.juc;

public class TestCompareAndSwap {

    public static void main(String[] args) {
        final CompareAndSwap cas = new CompareAndSwap();

        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    int expectedValue = cas.get();
                    boolean b = cas.compareAndSet(expectedValue, (int) (Math.random() * 101));
                    System.out.println(b);
                }
            }).start();
        }
    }
}


class CompareAndSwap {

    private int value;

    //获取内存值
    public synchronized int get() {
        return value;
    }

    //比较
    public synchronized int compareAndSwap(int expectedValue, int newValue) {
        int oldValue = value;

        if (oldValue == expectedValue) {//旧值等于预估值，则修改值
            this.value = newValue;
        }

        return oldValue;
    }

    //设置
    public synchronized boolean compareAndSet(int expectedValue, int newValue) {
        return expectedValue == compareAndSwap(expectedValue, newValue);//旧值是否等于预估值
    }
}

在这里插入图片描述

4. ConcurrentHashMap 锁分段机制

4.1 ConcurrentHashMap

Java 5.0 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。
ConcurrentHashMap 同步容器类是Java 5 增加的一个线程安全的哈希表。对与多线程的操作，介于HashMap 与 Hashtable 之间。内部采用“锁分段”机制替代 Hashtable 的独占锁。进而提高性能。
此包还提供了设计用于多线程上下文中的 Collection 实现：
ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、CopyOnWriteArrayList 和 CopyOnWriteArraySet。当期望许多线程访问一个给定 collection 时，ConcurrentHashMap 通常优于同步的 HashMap，ConcurrentSkipListMap 通常优于同步的 TreeMap。当期望的读数和遍历远远大于列表的更新数时，CopyOnWriteArrayList 优于同步的 ArrayList。

在这里插入图片描述

通过Iterator来实现的，当遍历这个List的时候，会生成一个ArrayList.Itr对象，这个私有内部类实现了Iterator接口，也就是说上面这段代码与下面这段代码效果一样：
　　Iterator it = list.iterator() ;
　　while(it.hasNext()){
　　　　　　String temp = it.next() ;
　　　　　　list.remove(temp) ;　
　　}
在ArrayList中有一变量记录的当前这个ArrayList被修改的次数，每当调用add/remove方法就会把该参数的值加一，当生成Iterator对象时该对象会记录当前状态ArrayList的修改次数，然后在每次调用it.next()时就会判断当前ArrayList修改次数是否和它记录的相同，如果不同就抛出异常。例如上面等效后的代码，当执行 it = list.iterator() ;时 it对象记录在执行这句代码之前list对象的修改次数，当第一次执行it.next()语句时不会发生异常，因为这时list还没有被修改，但是当第二次执行it.next()时list已经通过list.remove(temp)代码修改了其内部的修改次数变量，所以导致it对象记录的修改次数和list的修改次数不同，所以就抛出了异常。

只需记住的准则是：使用Iterator遍历集合时是不能修改集合的。
解决

package com.atguigu.juc;

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * CopyOnWriteArrayList/CopyOnWriteArraySet : “写入并复制”
 * 注意：添加操作多时，效率低，因为每次添加时都会进行复制，开销非常的大。并发迭代操作多时可以选择。
 */
public class TestCopyOnWriteArrayList {

	public static void main(String[] args) {
		HelloThread ht = new HelloThread();
		
		for (int i = 0; i < 10; i++) {
			new Thread(ht).start();
		}
	}
	
}

class HelloThread implements Runnable{
	
//	private static List<String> list = Collections.synchronizedList(new ArrayList<String>());
	
	private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
	
	static{
		list.add("AA");
		list.add("BB");
		list.add("CC");
	}

	@Override
	public void run() {
		
		Iterator<String> it = list.iterator();
		
		while(it.hasNext()){
			System.out.println(it.next());
			
			list.add("AA");
		}
		
	}
	
}

4.2 CountDownLatch 闭锁

Java 5.0 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。
CountDownLatch 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
闭锁可以延迟线程的进度直到其到达终止状态，闭锁可以用来确保某些活
动直到其他活动都完成才继续执行：
确保某个计算在其需要的所有资源都被初始化之后才继续执行;
确保某个服务在其依赖的所有其他服务都已经启动之后才启动;
等待直到某个操作所有参与者都准备就绪再继续执行。

package com.atguigu.juc;

import java.util.concurrent.CountDownLatch;

/*
 * CountDownLatch ：闭锁，在完成某些运算是，只有其他所有线程的运算全部完成，当前运算才继续执行
 */
public class TestCountDownLatch {

	public static void main(String[] args) {
		final CountDownLatch latch = new CountDownLatch(50);
		LatchDemo ld = new LatchDemo(latch);

		long start = System.currentTimeMillis();

		for (int i = 0; i < 50; i++) {
			new Thread(ld).start();
		}

		try {
			latch.await();
		} catch (InterruptedException e) {
		}

		long end = System.currentTimeMillis();

		System.out.println("耗费时间为：" + (end - start));
	}

}

class LatchDemo implements Runnable {

	private CountDownLatch latch;

	public LatchDemo(CountDownLatch latch) {
		this.latch = latch;
	}

	@Override
	public void run() {

		try {
			for (int i = 0; i < 50000; i++) {
				if (i % 2 == 0) {
					System.out.println(i);
				}
			}
		} finally {
			latch.countDown();
		}

	}

}

资料来源：https://www.bilibili.com/video/BV14W411u7gB?p=6

Aluem

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java JUC学习笔记 day01

文章目录Java JUC学习笔记1. Java JUC 简介2. volatile 关键字-内存可见性2.1 内存可见性2.1.1 示例2.2 volatile 关键字3. 原子变量-CAS算法3.1 CAS 算法3.2 原子变量3.3 原子性问题示例3.4 使用CAS解决问题3.5 模拟CAS算法4. ConcurrentHashMap 锁分段机制4.1 ConcurrentHashMap4.2 CountDownLatch 闭锁5. 实现 Callable 接口5.1 Callable 接口6. Loc
复制链接

扫一扫

专栏目录