独角兽企业重金招聘Python工程师标准>>>
Static Synchronised是类级别的锁,独占的 绝对同步, 可以跨多对象同步。
Synchronised是对象锁,对每一个对象加锁 。
Synchronised的方法或快是相对安全 一般用于set value时用,而不是get value
Oracle: undo作用是当客户端DML操作时,oracle 是把旧值放入undo表空间,如果操作中途失败,去undo 找出来 回滚回去用的。因此 oracle 是consistent read 的,客户端9点找数据,就查9点时候的数据。如果中途有人DML操作,则一致性读特性就提示用户数据变了 报一个错 snapshot too old exception;
Synchronised方法可以循环嵌套
Synchronised内部有异常的话 锁自动释放
Synchronised 块可以锁 类 和 变量 ,synchronised (this) or synchronised (new Object (“”))
Volatile:变量在各个线程中可见,每个线程都可以修改volatile 变量,但不具备原子性
AtomicInteger:支持多线程可见并发的原子操作,集成了volatile 适合多线程+ - 步长
Wait/notify: 线程之间的通信,必须配合synchronised 使用,wait 释放锁 notify 不释放锁。
两个线程互相通信可以写成死循环的形式互相监控 但是这样实现很不好,改进:
Final Object lock = new Object();Thread t1 = new Thread(new Runnable(){syncronised(lock) {if (list.size() == 5) {// 发出通知 唤醒另外一边的线程 ,另一边一定是在wait,并没有释放lock锁,所以不会立刻通知,运行完才释放lock.notify(); }}},"t1");Thread t2 = new Thread(new Runnable(){syncronised(lock) {if (list.size() != 5) {lock.wait(); // 等待被唤醒}logger.debug("还没有被唤醒");}},"t2");// 注:t2必须先执行,先开始等待 再t1进行通知才可以!
实现实时的通知唤醒效果:
Final CountDownLatch countDownLatch = new CountDownLatch (1);Thread t1 = new Thread(new Runnable(){if (list.size() == 5) {countDownLatch.countDown(); //发通知}},"t1");Thread t2 = new Thread(new Runnable(){if (list.size() != 5) {countDownLatch.await(); // 等待被唤醒}logger.debug("还没有被唤醒");},"t2");
LinkedBlockingQueue: 就是用wait 和 notify + linkedlist 制作的
单利模式支持多线程:static inner class模式 + holder 模式, 如果是单利,hashcode()一定一样
public class Sing {private static class InnerSign {private static InnerSign holder = new InnerSing();}public static Sing getInstance() {return InnerSign.holder; // lazy loading}}
让集合线程安全: Collections.syncronisedMap(new HashMap<String,String>())
并发类容器:
-ConcurrentMap容器实现是用减少锁力度的方法,分成多个小的hashtable()叫做segment然后对每一个segment加锁。
ConcurrentHashMap() //无序的ConcurrentSkipListMap() //有序的
-CopyOnWrite容器,当对一个元素执行写操作时,不对当前容器操作,先copy一个副本,对新的操作,然后指引用到旧的容器,这样就可以并发读操作,实现了读写分离 读多写少下使用多。
CopyOnWriteArrayList() CopyOnWriteArraySet()
ConcurrentLinkedQueue() //先进先出,非阻塞,不可以为null
ArrayBlockingQueue //有界的,一般并发访问很大的时候用 对超过界限时候做一个处理策略
LinkedBlockingQueue //无界的,性能比较好,在数据来的不大时候可以选用
SynchronousQueue(); //没有缓冲队列 生产了会直接被消费,不直接add元素,必须先take才能add
PriorityBlockingQueue() //里面元素<Item>必须实现Comparable接口 ,一个有优先级的队列
DelayQueue() //带有延迟时间的队列,设一个延迟时间 当时间到了元素自动出来,多用于任务超时处理,里面东东必须实现Delayed借口。
-----------------------------------------------------------------------------------------------------
Future模式:请求后直接返回一个假对象,后台慢慢加载真实数据,加载完了再返回。异步加载
Master-worker 模式:Master主要负责接收和分配任务 Worker负责处理任务,好处是讲大任务分解成小任务,并行计算。手写strorm。
实现代码可以参考:
private ConcurrentLinkedQueue<Task> workQueue = new ConcurrentLinkedQueue<>();private HashMap<String, Thread> workers = new HashMap<>();private ConcurrentHashMap<String, Object> result = new ConcurrentHashMap<>();
Message Queue: 本质就是有消息堆积能力的容器 RocketMQ.来缓解消费端压力。不能实现实时。如果要实时,建议使用TCP直连,例如mina 或者 netty.