Java同步控制类的使用

有时为了控制同步, 我们一般会是用synchronized关键字或者对于变量使用volatile 进行修饰, 来达到并发的一个控制

synchronized

可以锁类,
对象实例,
其他对象,
wait和notify要放在synchronized里面,
join是等待其他线程执行后在一起执行,
yeild放弃争抢cpu执行
start是开启一个线程,会去调用runable接口的run方法,或者重写thread重写的run方法,也就是一个实现一个继承

  • wait、notify方法

1.因为涉及到对象锁,他们必须都放在synchronized中来使用. Wait、Notify一定要在synchronized里面进行使用。
2.Wait必须暂定当前正在执行的线程,并释放资源锁,让其他线程可以有机会运行
3. notify/notifyall: 唤醒因锁池中的线程,使之运行
注意:一定要在线程同步中使用,并且是同一个锁的资源

  • wait与sleep区别

对于sleep()方法,我们首先要知道该方法是属于Thread类中的。而wait()方法,则是属于Object类中的。
sleep()方法导致了程序暂停执行指定的时间,让出cpu该其他线程,但是他的监控状态依然保持者,当指定的时间到了又会自动恢复运行状态。
在调用sleep()方法的过程中,线程不会释放对象锁。
而当调用wait()方法的时候,线程会放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象调用notify()方法后本线程才进入对象锁定池准备
获取对象锁进入运行状态。

  • Lock与synchronized 关键字的区别

Lock 接口可以尝试非阻塞地获取锁 当前线程尝试获取锁。如果这一时刻锁没有被其他线程获取到,则成功获取并持有锁。
Lock 接口能被中断地获取锁 与 synchronized 不同,获取到锁的线程能够响应中断,当获取到的锁的线程被中断时,中断异常将会被抛出,同时锁会被释放。
Lock 接口在指定的截止时间之前获取锁,如果截止时间到了依旧无法获取锁,则返回。

ReentrantLock 类

  • 可重入

单线程可以重复进入,但要重复退出

  • 可中断

lockInterruptibly()

  • 可限时

超时不能获得锁,就返回false,不会永久等待构成死锁

  • 公平锁

先来先得 public ReentrantLock(boolean fair)
public static ReentrantLock fairLock = new ReentrantLock(true);

案例:

    1. 可重入
package com.learn.first.jdkThread;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 手动说可重入(ReentrantLock)
 *  1. 重入锁, 锁几次需要实施方案几次
 *  2. 可中断锁,
 */
public class ReentrankLockThread implements Runnable {
    /**手动锁*/
    public static ReentrantLock lock = new ReentrantLock();
    public static int i = 0;
    public void run() {
        for (int j = 0; j < 100000; j++) {
            lock.lock(); // 加锁 , 锁加几次, 则需要释放几次
            //lock.lock();
            try {
                i++; // 保证多线程下的安全操作
            } finally {
                lock.unlock(); // 释放锁
            }
        }

    }

    public static void main(String[] args) {
        ReentrankLockThread reen = new ReentrankLockThread();
        Thread t1 = new Thread(reen);
        Thread t2 = new Thread(reen);
        t1.start();t2.start();
        try {
            t1.join(); // 主线程等待t1执行完
            t2.join(); // 主线程等待t2执行完
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 加锁后, 值200000
        System.out.println(reen.i);
    }
}
    1. 可中断
package com.learn.first.jdkThread;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrankLockInterruptor implements Runnable {
    private static ReentrantLock lock1 = new ReentrantLock();
    private static ReentrantLock lock2 = new ReentrantLock();

    private int lock;

    /**
     * 控制加锁顺序, 构造死锁
     * @param lock
     */
    public ReentrankLockInterruptor(int lock) {
        this.lock = lock;
    }

    public void run() {
        try {
            if (lock == 1) {
                lock1.lockInterruptibly(); // 加入可中断锁
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
                lock2.lockInterruptibly();
            } else {
                lock2.lockInterruptibly();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
                lock1.lockInterruptibly();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock1.isHeldByCurrentThread()) {
                lock1.unlock(); // 释放锁
            }
            if (lock2.isHeldByCurrentThread()) {
                lock2.unlock();// 释放锁
            }
            System.out.println(Thread.currentThread().getId() + ":线程退出");
        }
    }

    public static void main(String[] args) {
        ReentrankLockInterruptor t1 = new ReentrankLockInterruptor(1);
        ReentrankLockInterruptor t2 = new ReentrankLockInterruptor(2);
        Thread th1 = new Thread(t1);
        Thread th2 = new Thread(t2);
        th1.start();th2.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // s死锁检查
        DeadlockChecker.check();
    }
}
package com.learn.first.jdkThread;

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;

/**
 * 检查处于死锁状态的线程,并中断掉
 */
public class DeadlockChecker {
    // Java 虚拟机线程系统的管理接口
    private final static ThreadMXBean mbean = ManagementFactory.getThreadMXBean();
    final static Runnable deadLockCheck = new Runnable() {
        public void run() {
            while (true) {
                long[] deadlockedThreads = mbean.findDeadlockedThreads();
                if (deadlockedThreads != null) {
                    ThreadInfo[] threadInfo = mbean.getThreadInfo(deadlockedThreads);
                    for (Thread t : Thread.getAllStackTraces().keySet()) {
                        for (int i = 0; i < threadInfo.length; i++) {
                            if (t.getId() == threadInfo[i].getThreadId()) {
                                t.interrupt();
                            }
                        }

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

            }
        }
    };


    public static void check() {
        Thread t = new Thread(deadLockCheck);
        t.setDaemon(true);
        t.start();
    }
}

    1. 超时
package com.learn.first.jdkThread;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 锁超时后释放
 */
public class ReenTranckTimeLock implements Runnable {
    private static ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        try {
            // 锁 5秒,后释放
            if (lock.tryLock(5, TimeUnit.SECONDS)) {
                Thread.sleep(5000);
            } else {
                System.out.println("get lock failed");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        ReenTranckTimeLock t1 = new ReenTranckTimeLock();
        Thread th1 = new Thread(t1);
        Thread thread = new Thread(t1);
        th1.start();
        thread.start();

    }
}

Condition

  • 概述

类似于 Object.wait()和Object.notify() 与ReentrantLock结合使用

  • 主要接口

void await() throws InterruptedException;
void awaitUninterruptibly();
long awaitNanos(long nanosTimeout) throws InterruptedException;
boolean await(long time, TimeUnit unit) throws InterruptedException;
boolean awaitUntil(Date deadline) throws InterruptedException;
void signal(); void signalAll()#

  • API详解

await()方法会使当前线程等待,同时释放当前锁,当其他线程中使用signal()时或者signalAll()方法时,线 程会重新获得锁并继续执行。或者当线程被中断时,也能跳出等待。这和Object.wait()方法很相似。
awaitUninterruptibly()方法与await()方法基本相同,但是它并不会再等待过程中响应中断。 singal()方法用于唤醒一个在等待中的线程。相对的singalAll()方法会唤醒所有在等待中的线程。这和Obej ct.notify()方法很类似。

Semaphore (信号量)

  • 概述

Semaphore是一种基于计数的信号量。它可以设定一个阈值,基于此,多个线程竞争获取许可信号,做自己的申请后归还,超过阈值后,线程申请许可信号将会被阻塞。Semaphore可以用来构建一些对象池,资源池之类的,比如数据库连接池,我们也可以创建计数为1的Semaphore,将其作为一种类似互斥锁的机制,这也叫二元信号量,表示两种互斥状态。它的用法如下:
availablePermits函数用来获取当前可用的资源数量
wc.acquire(); //申请资源
wc.release();// 释放资源
共享锁
运行多个线程同时临界区

  • 主要接口

public void acquire()
public void acquireUninterruptibly()
public boolean tryAcquire()
public boolean tryAcquire(long timeout, TimeUnit unit)
public void release()

  • 案例
package com.learn.first.jdkThread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * 信号量 :
 * 允许运行多个线程同时共享
 */
public class SemapphoreDemo implements Runnable {
    final Semaphore sema  = new Semaphore(5);
    @Override
    public void run() {
        try {
            sema.acquire(); // 获取一个信号量
            // 模拟操作
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getId()+":done");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            sema.release();// 释放信号量
        }
    }

    public static void main(String[] args) {
        ExecutorService execu = Executors.newFixedThreadPool(6);
        final SemapphoreDemo demo = new SemapphoreDemo();
        for (int i = 0; i < 20; i++) {
            execu.submit(demo);
        }
        execu.shutdown();
    }
}

ReadWriteLock (读写锁)

  • 概述

ReadWriteLock是JDK5中提供的读写分离锁

  • 访问情况

读-读不互斥:读读之间不阻塞。 读-写互斥:读阻塞写,写也会阻塞读。 写-写互斥:写写阻塞。

  • 主要接口

private static ReentrantReadWriteLock readWriteLock=new ReentrantReadWriteLock();

private static Lock readLock = readWriteLock.readLock();
private static Lock writeLock = readWriteLock.writeLock();

CountDownLatch (倒数计时器)

  • 概述

CountDownLatch 类位于java.util.concurrent包下,利用它可以实现类似计数器的功能。比如有一个任务A,它要等待其他4个任务执行完毕之后才能执行,此时就可以利用CountDownLatch来实现这种功能了。CountDownLatch是通过一个计数器来实现的,计数器的初始值为线程的数量。每当一个线程完成了自己的任务后,计数器的值就会减1。当计数器值到达0时,它表示所有的线程已经完成了任务,然后在闭锁上等待的线程就可以恢复执行任务。

倒数计时器
一种典型的场景就是火箭发射。在火箭发射前,为了保证万无一失,往往还要进行各项设备、仪器的检查。 只有等所有检查完毕后,引擎才能点火。这种场景就非常适合使用CountDownLatch。它可以使得点火线程
,等待所有检查线程全部完工后,再执行

  • 主要接口

static final CountDownLatch end = new CountDownLatch(10);
end.countDown();
end.await();

  • 案例
package com.learn.first.jdkThread;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchDemo implements Runnable {
    static final CountDownLatch end = new CountDownLatch(10); // 倒计时砸栏
    static final CountDownLatchDemo demo = new CountDownLatchDemo();
    @Override
    public void run() {
        try {
            // 模拟任务执行
            Thread.sleep(1000);
            System.out.println("1");
            // 执行完任务, 计数器-1
            end.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.submit(demo);
        }
        // 等待线程执行
        end.await();
        // 线程任务执行完毕
        System.out.println("执行完毕.....");
        executorService.shutdown();

    }
}

CyclicBarrier (可循环使用的一个砸栏)

CyclicBarrier初始化时规定一个数目,然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时,所有进入等待状态的线程被唤醒并继续。
CyclicBarrier就象它名字的意思一样,可看成是个障碍, 所有的线程必须到齐后才能一起通过这个障碍。
CyclicBarrier初始时还可带一个Runnable的参数, 此Runnable任务在CyclicBarrier的数目达到后,所有其它线程被唤醒前被执行。

比如: 一个队伍有5个人(5个线程), 现在要执行2个操作, 1一个是集合, 一个是执行任务;
集合: 1. 等待5个线程都准备好了, 说明集合了, 2. 然后去做执行任务(5个任务),任务都完成了, 说明整个完成了
把5个人共通要做一件事, 作为一个拦截, 做完后, 继续做其他事情

  • 概述

循环栅栏 Cyclic意为循环,也就是说这个计数器可以反复使用。比如,假设我们将计数器设置为10。那么凑齐第一批1 0个线程后,计数器就会归零,然后接着凑齐下一批10个线程

  • 主要接口

public CyclicBarrier(int parties, Runnable barrierAction)
barrierAction就是当计数器一次计数完成后,系统会执行的动作
await()

  • 例子
class Writer extends Thread {
	private CyclicBarrier cyclicBarrier;
	public Writer(CyclicBarrier cyclicBarrier){
		 this.cyclicBarrier=cyclicBarrier;
	}
	@Override
	public void run() {
		System.out.println("线程" + Thread.currentThread().getName() + ",正在写入数据");
		try {
			Thread.sleep(3000);
		} catch (Exception e) {
			// TODO: handle exception
		}
		System.out.println("线程" + Thread.currentThread().getName() + ",写入数据成功.....");
		
		try {
			cyclicBarrier.await();
		} catch (Exception e) {
		}
		System.out.println("所有线程执行完毕..........");
	}

}

public class Test001 {

	public static void main(String[] args) {
		CyclicBarrier cyclicBarrier=new CyclicBarrier(5);
		for (int i = 0; i < 5; i++) {
			Writer writer = new Writer(cyclicBarrier);
			writer.start();
		}
	}

}

LockSupport

  • 概述

提供线程阻塞原语

  • 主要接口

LockSupport.park(); LockSupport.unpark(t1);

  • 与suspend()比较

不容易引起线程冻结

  • 中断响应

能够响应中断,但不抛出异常。 中断响应的结果是,park()函数的返回,可以从Thread.interrupted()得到中断标志

ReentrantLock 的实现

源码中可知:

  • CAS状态
  • 等待队列
  • park()

并发容器 使用

Collections

Collections.synchronizedMap
public static Map m=Collections.synchronizedMap(new HashMap());

synchronizedList

synchronizedSet

ConcurrentHashMap

高性能: 安全

阻塞队列与非阻塞队

阻塞队列与普通队列的区别在于,当队列是空的时,从队列中获取元素的操作将会被阻塞,或者当队列是满时,往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞,直到其他的线程往空的队列插入新的元素。同样,试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞,直到其他的线程使队列重新变得空闲起来,如从队列中移除一个或者多个元素,或者完全清空队列.

1.ArrayDeque, (数组双端队列)
2.PriorityQueue, (优先级队列)
3.ConcurrentLinkedQueue, (基于链表的并发队列)
4.DelayQueue, (延期阻塞队列)(阻塞队列实现了BlockingQueue接口)
5.ArrayBlockingQueue, (基于数组的并发阻塞队列)
6.LinkedBlockingQueue, (基于链表的FIFO阻塞队列)
7.LinkedBlockingDeque, (基于链表的FIFO双端阻塞队列)
8.PriorityBlockingQueue, (带优先级的无界阻塞队列)
9.SynchronousQueue (并发同步阻塞队列)

BlockingQueue 接口 (队列)

多线程中共享数据容器
ReentrantLock 与 Condition
读取: 没有数据,等待写入,否则读取
写入: 有数据,等待被读取,否则写入
BlockingQueue接口为代表的阻塞队列

ConcurrentLinkedQueue (高性能的队列)

ConcurrentLinkedQueue : 是一个适用于高并发场景下的队列,通过无锁的方式,实现
了高并发状态下的高性能,通常ConcurrentLinkedQueue性能好于BlockingQueue.它
是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最先
加入的,尾是最近加入的,该队列不允许null元素。
ConcurrentLinkedQueue重要方法:
add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中这俩个方法没有任何区别)
poll() 和peek() 都是取头元素节点,区别在于前者会删除元素,后者不会。

BlockingQueue

阻塞队列(BlockingQueue)是一个支持两个附加操作的队列。这两个附加的操作是:
在队列为空时,获取元素的线程会等待队列变为非空。
当队列满时,存储元素的线程会等待队列可用。
阻塞队列常用于生产者和消费者的场景,生产者是往队列里添加元素的线程,消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器,而消费者也只从容器里拿元素。
BlockingQueue即阻塞队列,从阻塞这个词可以看出,在某些情况下对阻塞队列的访问可能会造成阻塞。被阻塞的情况主要有如下两种:

  1. 当队列满了的时候进行入队列操作
  2. 当队列空了的时候进行出队列操作
    因此,当一个线程试图对一个已经满了的队列进行入队列操作时,它将会被阻塞,除非有另一个线程做了出队列操作;同样,当一个线程试图对一个空队列进行出队列操作时,它将会被阻塞,除非有另一个线程进行了入队列操作。
    在Java中,BlockingQueue的接口位于java.util.concurrent 包中(在Java5版本开始提供),由上面介绍的阻塞队列的特性可知,阻塞队列是线程安全的。
    在新增的Concurrent包中,BlockingQueue很好的解决了多线程中,如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类,为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员,包括他们各自的功能以及常见使用场景。
    认识BlockingQueue
    阻塞队列,顾名思义,首先它是一个队列,而一个队列在数据结构中所起的作用大致如下图所示:
    从上图我们可以很清楚看到,通过一个共享的队列,可以使得数据由队列的一端输入,从另外一端输出;
    常用的队列主要有以下两种:(当然通过不同的实现方式,还可以延伸出很多不同类型的队列,DelayQueue就是其中的一种)
      先进先出(FIFO):先插入的队列的元素也最先出队列,类似于排队的功能。从某种程度上来说这种队列也体现了一种公平性。
      后进先出(LIFO):后插入队列的元素最先出队列,这种队列优先处理最近发生的事件。
    多线程环境中,通过队列可以很容易实现数据共享,比如经典的“生产者”和“消费者”模型中,通过队列可以很便利地实现两者之间的数据共享。假设我们有若干生产者线程,另外又有若干个消费者线程。如果生产者线程需要把准备好的数据共享给消费者线程,利用队列的方式来传递数据,就可以很方便地解决他们之间的数据共享问题。但如果生产者和消费者在某个时间段内,万一发生数据处理速度不匹配的情况呢?理想情况下,如果生产者产出数据的速度大于消费者消费的速度,并且当生产出来的数据累积到一定程度的时候,那么生产者必须暂停等待一下(阻塞生产者线程),以便等待消费者线程把累积的数据处理完毕,反之亦然。然而,在concurrent包发布以前,在多线程环境下,我们每个程序员都必须去自己控制这些细节,尤其还要兼顾效率和线程安全,而这会给我们的程序带来不小的复杂度。好在此时,强大的concurrent包横空出世了,而他也给我们带来了强大的BlockingQueue。(在多线程领域:所谓阻塞,在某些情况下会挂起线程(即阻塞),一旦条件满足,被挂起的线程又会自动被唤醒)

微服务架构的分布式事务控制解决方案

09-06
1、课程简介 Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发,如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等,都可以用Spring Boot的开发风格做到一键启动和部署。        在本套课程中,我们将全面的讲解Spring Cloud技术栈, 从环境的部署到技术的应用,再到项目实战,让我们不仅是学习框架技术的使用,而且可以学习到使用Spring Cloud如何解决实际的问题。 Spring Cloud各个组件相互配合,合作支持了一套完整的微服务架构。 - 注册中心负责服务的注册与发现,很好将各服务连接起来 - 断路器负责监控服务之间的调用情况,连续多次失败进行熔断保护。 - API网关负责转发所有对外的请求和服务 - 配置中心提供了统一的配置信息管理服务,可以实时的通知各个服务获取最新的配置信息 - 链路追踪技术可以将所有的请求数据记录下来,方便我们进行后续分析 - 各个组件又提供了功能完善的dashboard监控平台,可以方便的监控各组件的运行状况 2、适应人群 有一定的Java基础,并且要有一定的web开发基础。 3、课程亮点        系统的学习Spring Cloud技术栈,由浅入深的讲解微服务技术。涵盖了基础知识,原理剖析,组件使用,源码分析,优劣分析,替换方案等,以案例的形式讲解微服务中的种种问题和解决方案 l  微服务的基础知识 n  软件架构的发展史 n  微服务的核心知识(CAP,RPC等) l  注册中心 n  Eureka搭建配置服务注册 n  Eureka服务端高可用集群 n  Eureka的原理和源码导读 n  Eureka替换方案Consul n  Consul下载安装&服务注册&高可用 l  服务发现与服务调用 n  Ribbon负载均衡基本使用&源码分析 n  Feign的使用与源码分析 n  Hystrix熔断(雪崩效应,Hystrix使用与原理分析) n  Hystrix替换方案Sentinel l  微服务网关 n  Zuul网关使用&原理分析&源码分析 n  Zuul 1.x 版本的不足与替换方案 n  SpringCloud Gateway深入剖析 l  链路追踪 n  链路追踪的基础知识 n  Sleuth的介绍与使用 n  Sleuth与Zipkin的整合开发 l  配置中心 n  SpringClond Config与bus 开发配置中心 n  开源配置中心Apollo 4、主讲内容 章节一: 1.     微服务基础知识 2.     SpringCloud概述 3.     服务注册中心Eureka 4.     Eureka的替换方案Consul 章节二: 1.     Ribbon实现客户端负载均衡 2.     基于Feign的微服务调用 3.     微服务熔断技术Hystrix 4.     Hystrix的替换方案Sentinel 章节三: 1.     微服务网关Zuul的基本使用 2.     Zuul1.x 版本的不足和替换方案 3.     深入SpringCloud Gateway 4.     链路追踪Sleuth与Zipkin 章节四: 1.     SpringCloud Config的使用 2.     SpringCloud Config结合SpringCloud Bus完成动态配置更新 3.     开源配置中心Apollo
©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值