在多线程的使用中，有时会碰到死锁，死锁会造成应用程序阻塞，浪费系统资源。下面探讨如何发现和解决死锁：
首先先写一段能够产生死锁的代码：
1 | private static Object lock1=new Object(); |
运行上面的结果，线程会各自阻塞在同步锁的那个地方，产生了死锁，运行结果如下：
1 | 线程1获得 lock1 |
我们使用jps命令， 查询Java的线程，如下：
使用jstack 16071命令查看堆栈信息
从上面可以看出来，两个线程都在等待一个内存地址，这个就是我们的死锁
最近看到线上的项目线程数过大的报警，开始还是不知道什么原因，因为很多项目都使用同样的线程池管理代码，认为那个项目是偶然的因素造成的，后来经过分析，发现线程数每天都在增加。其他的项目由于发布导致线程会从零开始计算，所以没有那么快达到报警值。 触发报警的代码大概如下：
1 | boolean start=true; |
上面的代码存在两个问题：
start是个主线程的变量，在主线程修改值，子线程的while循环不会停止
上述代码能够停止，因为在内部调用`Thread.sleep方法，导致线程内的变量刷新
newFixedThreadPool 线程池没有调用shutdown方法，导致线程不会被回收。
改正方法：
start 设置成线程共享变量volatile类型
在最后调用停止的时候，让线程池进行回收
修改后代码如下：
1 |
|
线程池在最后不使用后，为什么线程没有被释放？GC为什么没有把线程池对象回收？是怎么做到的？
目前还没有找到问题的答案，等找到后回来更新。
1 | { |
相当于 amount>=1 and amount<=100
1 | { |
script查询 可以对查询出的字段进行再次计算。
1 | GET order/_search |
区别:
Filter：在查询过程中，Filter只判断该文档是否满足条件，只有YES或者NO。
ES会对它的结果进行缓存，所以相较于Query而言Filter的速度会更快一些。
Query： 除了问YES或NO，还会问匹配的程度。
过滤查询已被弃用，并在ES 5.0中删除。现在使用bool查询代替。
bool 查询是一个组合查询，返回一个bool值。 包含must,should,filter等查询
must:相当于and,必须满足
should:相当于or,代表或者意思
filter：是一个bool表达式。
1 | { |
相当于mysql中的 1=1 and ((desc like ‘%收入%’ and amount>=10 and amount<=50>) or name =’user’)
在mysql中，聚合用group by，对于聚合后的计算用sum，avg等聚合函数计算，在es中，groupby 后面的字段称为桶，sum等聚合函数称为指标。
如：
1 | select sex,sum(age) from user group by sex |
上面的sql中,sex和sum都是查询的指标，sex是桶。
聚合的写法：
1 | { |
对于聚合来说，es中的聚合函数有，sum,avg,stats,max,min等，聚合方式可以归为以下几类：
单字段单指标聚合单字段多指标聚合 多字段单指标聚合聚合后筛选1 | { |
1 | { |
对索引中的两个字段一起聚合,相当于group by xxx,yyy
1 | { |
1 | { |
ES中有一个区别于传统DB的聚合方式，对索引中的两个字段分别聚合，相当于mysql中group by 'xxx', group by 'yyy'，统计后的结果分布在各个桶里面
1 | { |
1 | "aggregations" : { |
也可以多个字段各自统计
1 | { |
聚合后结果如下：
1 | "aggregations" : { |
ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。我们可以这么去理解：
在搜索引擎之前，使用的基本上都是关系型的数据库（mysql,mssql,oracle）,在关系型数据库中有Database,Table和row.
对于es来说，有Index ,Type,Document来与之对应，关系如下：
| 关系数据库 | 数据库 | 表 | 行 |
| ES | Index | Type | Document |
注意： 每个 Index （即数据库）的名字必须是小写。
Elastic 6.x 版只允许每个 Index 包含一个 Type，7.x 版将会彻底移除 Type
1 |
|
成功返回：
1 | { |
1 |
|
或者用_mget返回json信息
1 | GET /_mget |
1 | { |
1 |
|
在关系型数据库中，我们需要指定表字段和字段的类型，在ES也可以松散的定义数据，也可以订制指定的类型
1 | put /fwdatabase/_mapping/order |
curl -X PUT -H ‘Content-type: application/json’ -d ‘{“properties”:{“orderId”:{“type”:”keyword”},”shortTime”:{“type”:”keyword”},”amount”:{“type”:”double”},”desc”:{“type”:”text”}}}’ http://localhost:9200/fwdatabase/_mapping/order
查询Index所包含的Type
1 |
|
其他一些查询
1 | /_search |
修改Type一般可以只对数据进行局部更新，或者删除当前Index后重新创建一个新的type,此处略去不去过多的讲述。
document相当于mysql中的行数据，我们可以通过接口对es的数据进行管理。
单条插入数据
1 | POST /fwdatabase/order |
插入成功返回信息：
1 | { |
插入的数据可以通过_search接口查询出来：
1 |
|
查询结果和相关注释如下：
1 | { |
其中 _index 和 _type是对应的索引和类型的名称，_id是系统自动指定的唯一标识的主键。也可以自己之指定：
1 | POST /fwdatabase/order/1 //这里指定_id的值 |
批量插入数据可以减少与es的网络请求，从而加快插入的效率，调用的是_bulk的接口，写法如下：（为了方便后面的演示，在此处插入点数据）：
1 |
|
插入完成后的数据
按id更新数据
1 | POST fwdatabase/order/1 |
批量更新
批量更新与批量插入是同一个接口，在批量插入的时候指定_id,es会自动选择插入和更新。
1 | POST /fwdatabase/order/_bulk |
局部更新
局部更新可以增加一个document的字段，其他数据保持不变:
1 |
|
id=PX0AvWgBNfbilfsxyX-V的数据增加一个tags列。
按id删除
1 | DELETE fwdatabase/order/1 |
删除Id为1的数据。
或者用query的查询删除也可以：
1 | POST fwdatabase/order/_delete_by_query |
term是精确查询，后面查询会讲到
按查询结果删除
1 | POST fwdatabase/order/_delete_by_query |
es查询分为两种，一种是参数存在与url中，形式/index/type/_search?q=_id:1
如：
1 | GET /fwdatabase/order/_search?q=_id:P30AvWgBNfbilfsxyX-V |
称为： Search Lite API
一种是利用POST方法提交json数据，实现查询（上面已经演示），称为：DSL查询
dsl更具有可读性，推荐使用。
Search Lite API查询
由于这种查询方式，不太场采用，只是简单介绍下，不做深入探究。
1.1. 按ID查询
1 | GET /index/type/_search?q=_id:1 |
1.2. 查询指定的字段
只查询orderId，amount字段。
1 | GET /fwdatabase/order/_search?q=_id:P30AvWgBNfbilfsxyX-V&_source=orderId,amount |
1.3. 排序和分页
排序:
1 | GET /fwdatabase/order/_search?sort=amount:desc |
分页：
1 | GET /fwdatabase/order/_search?sort=amount:desc&from=0&size=2 |
（DSL）查询
2.1 精确查询
精确查询相当于mysql中的等于（=），在es中使用的term关键字
查询user用户的收入和支出情况：
1 | POST /fwdatabase/order/_search |
查询user和user1的收支情况：
1 | POST /fwdatabase/order/_search |
多个精确条件查询
这个是需要其他高级的表达式，此处先不着急，留个问题在这。
2.2 模糊查询
match
1 | POST /fwdatabase/order/_search |
查询出所有desc为包含收入的数据。
如果用match下指定了一个确切值，在遇到数字，日期，布尔值或者not_analyzed 的字符串时，将是精确搜索.
1 | POST /fwdatabase/order/_search |
2.3 分页
1 | POST /fwdatabase/order/_search |
2.4 排序
默认正序
1
2
3
4
5
6
{
"from":0,
"size":10,
"sort":"amount"
}
倒序
1 | { |
多条件排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
"sort": [
{
"amount": {
"order": "desc"
}
},
{
"orderId": {
"order": "desc"
}
}
]
}
在Java中有int和integer两种类型，简单的说Integer是int的引用类型，但是这个引用的类型比较特殊，下面看几个demo:
Integer a1 = 140;
Integer a2 = 140;
System.out.println(a1 == a2);
Integer b1 = 120;
Integer b2 = 120;
System.out.println(b1 == b2);
运行结果是：
false
true
原因： Java对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直节从缓存中拿取，不会再从新创建对象。
所以120的时候地址是一样的，运行是true，大于127的时候重新开辟吗新的地址空间，地址不一致，为false。
当然我们也可以强制重新开辟一个新的变量：
Integer c1 = new Integer(120);
Integer c2 = new Integer(120);
System.out.println(c1 == c2);
Integer d1 = new Integer(120);
Integer d2 = 120;
System.out.println(d1 == d2);
运行结果是：
false
false
这样就更好的验证了我们上面的想法。
如果用Integer和int的值相比，会怎么样呢？
Integer e1 = new Integer(120);
int e2 = 120;
System.out.println(e1 == e2);
Integer f1 = new Integer(140);
int f2 = 140;
System.out.println(f1 == f2);
Integer g1 = 120;
int g2 = 120;
System.out.println(g1 == g2);
运行结果是：
true
true
true
原因： 当Integer和int对比的时候，Integer会自动拆箱成为int进行对比。
从上面的结论我们得出：
Integer在小于-128到127可以看似是值类型，超过这个范围后，会变成引用类型
Integer与int对比的时候会自动拆箱成int，再进行对比
综合上面，我开始有个一个疑问：
Integer i1 = 140;
Integer i2 = i1;
i1++;
System.out.println(i2);
System.out.println(i2 == i1);
运行结果是：
140
false
为什么i2没有随之i1的值改变而改变？
原因： Integer在进行运算的时候回自动调用内部函数intValue().
上面的代码可以拆解成：
Integer i1 = 140;
Integer i2 = i1;
i1=Integer.valueOf(i1.intValue()+1);
System.out.println(i2);
System.out.println(i2 == i1);
根据上面的所有情况，我们可以写一个终极的值类型和引用类型的转换：
Integer i1 = 120;
Integer i2 = i1;
Integer i3=i1+1;
Integer i4=i3-1;
System.out.println(i2);
System.out.println(i2 == i4);
运行结果：
120
true
而当i1=140的时候，i2 == i4就会变成false。
在计算机的世界，都是0和1 ，利用这个0和1组成了计算机的基础，数字是如何在计算机中表示的？二进制到底是什么？
在刚开始学编程的时候，有几种常见的数据基础的数据类型占用几个字节，如int 占16个字节（不同的语言体系不同，这里以C语言为例）。
一个字节可以表示两个数字0和1 ，占16个字节就可以用2^16个数字。
为了能够表示负数，单独保留一个字节作为符号位， 所以int的整型的范围是从-32768到32767 .
十进制的数字是逢十进一，二进制很简单是逢二进一，比如十进制：3+9=12. 在二进制中:1+1=10.
计算二进制的方法与十进制也相同，比如在十进制中想取个十百的数字，可以分别除10的倍数。
1 | 比如取456的各位的数： |
换成二进制的方法与十进制相同,唯一的区别是负数的表示方法不同。
1 | 比如获得13的二进制数据： |
负数的表示方法，取反码，然后加1：
1 |
|
二进制的运算效率高于其他计算方法，在日常的代码中，如果理解没有障碍的话，个人推荐优先使用位运算。
奇数和偶数的判断
1 |
|
取模运算
1 |
|
求绝对值
1 |
|
乘以2的次幂
1 |
|
前几天写了一个Java发送邮件的帮助类i，可以发送QQ和163的邮箱，也可以发送附件,写个一个主要的方法，其他的可以自己封装。代码如下：
引入pom：
1 | <dependency> |
1 | package com.pay.utils; |
上次大概说了CountDownLatch的使用，今天说下实现的原理，CountDownLatch的使用效果和Join差不多，实现起来也比较简单。
大体的思路就是一个死循环阻塞，等到某个条件满足后就跳出循环，继续执行后面的代码。执行逻辑如下：
我们下面分析下CountDownLatch的源码:
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
创建CountDownLatch 对象很简单，就是创建一个Sync对象。 Sync的对应的代码
Sync(int count) {
setState(count);
}
protected final void setState(int newState) {
state = newState;
}
这个可以确定给state设置了一个值。
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
doAcquireSharedInterruptibly 这个方法中有一个for(;;),这个是一个死循环, 直到tryAcquireShared 返回的r>=0.也就是state==0。
public void countDown() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
private void doReleaseShared() {
/*
* Ensure that a release propagates, even if there are other
* in-progress acquires/releases. This proceeds in the usual
* way of trying to unparkSuccessor of head if it needs
* signal. But if it does not, status is set to PROPAGATE to
* ensure that upon release, propagation continues.
* Additionally, we must loop in case a new node is added
* while we are doing this. Also, unlike other uses of
* unparkSuccessor, we need to know if CAS to reset status
* fails, if so rechecking.
*/
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
unparkSuccessor(h);
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}
**compareAndSetWaitStatus(h, 0, Node.PROPAGATE)**这个是用CAS的方法改变state的值。
在编程中，单例模式是我们常用的一种设计模式，功能是保证在整个系统只用一个该对象的对象，具体代码如下：
1 |
|
上面的代码我们知道并不是线程安全的，在多线程环境下，容易造成创建多个对象。 测试代码如下：
1 |
|
运行结果如下：
1 | 创建对象 |
对于上面的问题解决的方法有很多，比如使用加锁的方式，double检测的方式，为了验证最有方案我们把代码修改下：
1 |
|
测试代码：
1 |
|
1 | public static Singleton getInstance() { |
经过多次测试时间维持在410ms左右，下面是一次测试结果
1 |
|
这个虽然成功的保证了只有一个对象，但同样也会把其他的线程阻塞在创建的锁的前面，造成了性能上面的开销，如果创建一个对象的时间比较长，这个性能的开销是相当可观的。
1 |
|
1 |
|
上面的代码虽然聪明的避开的过多线程等待的原因，但是彻底消除线程排队的现象，因为创建对象分需要耗时，这样就给其他线程提供了“可乘之机”
共享变量是线程间同步的“轻量级锁”，彻底消除线程排队的现象，此处用于单例模式的设计，能够实现最小性能的开销：
1 | private volatile static Singleton singleton; |
1 |
|
在Java多线程中有一对配合使用过的两个方法，来实现线程间通信的功能–lock和wait, 由于这个需要获得锁，所以必须结合synchronized一起使用。首先我们先看一个例子：
public class LockWait {
static volatile List<String> itemContainer = new ArrayList<>();
static Object obj = new Object();
public static void main(String[] args) {
Thread th1 = new Thread(() -> {
synchronized (obj) {
for (int i = 0; i < 10; i++) {
System.out.println("th1添加元素");
itemContainer.add(String.valueOf(i));
if (itemContainer.size() == 5) {
System.out.println("th1线程发出通知");
obj.notify();
}
}
}
});
Thread th2 = new Thread(() -> {
synchronized (obj) {
System.out.println("进入th2线程");
if (itemContainer.size() != 5) {
try {
System.out.println("th2线程开始等待");
obj.wait();
System.out.println("th2线程等待结束");
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("th2线程结束");
}
}
});
th2.start();
th1.start();
}
}
输出结果如下：
进入th2线程
th2线程开始等待
th1添加元素
th1添加元素
th1添加元素
th1添加元素
th1添加元素
th1线程发出通知
th1添加元素
th1添加元素
th1添加元素
th1添加元素
th1添加元素
th2线程等待结束
th2线程结束
具体运行逻辑如下：
总结上面的运行结果，th2在wait的时候，th1可以持有锁。说明wait是释放锁，而notify不释放锁。
这样也就带来了一个弊端，无法实时的得到结果，就是说当List达到我们想要的结果的时候，th1线程一直还在持有锁，导致th2无法执行。
有没有更好办法呢？在Java中提供了一个CountDownLatch类：
public class CountDownLatchTest {
public static void main(String[] args) {
final List<String> itemContainer = new ArrayList<>();
final CountDownLatch countDownLanch = new CountDownLatch(1);
Thread th1 = new Thread(() -> {
for (int i = 0; i < 10; i++) {
try {
System.out.println("th1添加元素");
itemContainer.add(String.valueOf(i));
if (itemContainer.size() == 5) {
System.out.println("th1线程发出通知");
countDownLanch.countDown();
}
} catch (Exception e) {
e.printStackTrace();
}
}
});
Thread th2 = new Thread(() -> {
System.out.println("进入th2线程");
if (itemContainer.size() != 5) {
try {
System.out.println("th2线程开始等待");
countDownLanch.await();
System.out.println("th2线程等待结束");
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("th2线程结束");
}
});
th2.start();
th1.start();
}
}
运行结果：
进入th2线程
th1添加元素
th2线程开始等待
th1添加元素
th1添加元素
th1添加元素
th1添加元素
th1线程发出通知
th1添加元素
th2线程等待结束
th1添加元素
th2线程结束
th1添加元素
th1添加元素
th1添加元素
Update your browser to view this website correctly.&npsb;Update my browser now
