1.微服务的优缺点：
解耦，高容错性，一个服务出错不会影响到其它的服务。可以独立部署，
带来消息传递的延迟和互通的复杂性，当系统复杂到一定程度时，几十号人共同维护一个系统的效率很低，而且出问题的风险也很高。
2。cas 悲观锁和乐观锁
悲观锁比较保守，执行完后才解锁，认为在执行该过程中有人执行修改，目的是为了不让别人进行修改。
乐观锁使用版本号，版本号和设定的保持一致才执行修改，认为执行后判断此前的版本号是没有被修改过的，也就是数据没被修改过就执行修改。在表中加一个版本号列。
当冲突较少时使用乐观锁效率高，当冲突较高时使用悲观锁效率高。
条件变量使用，一定要用while
package com.example.demo.locktest;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
@Controller
public class LockTest {
@RequestMapping(value="lockTest",method=RequestMethod.GET)
public void lockTvest() {
Obj obj = new Obj();
Lock lock = new ReentrantLock();
Condition d1 = lock.newCondition();
ExecutorService pool= Executors.newFixedThreadPool(6);
Runnable a = new ThreadA(obj, lock, d1);
Runnable b = new ThreadB(obj, lock, d1);
Thread t1 = new Thread(a, "Thread-A");
Thread t2 = new Thread(b, "Thread-B");
// t1.start();
// t2.start();
pool.execute(t1);
pool.execute(t2);
// pool.shutdown();
}
}
package com.example.demo.locktest;
public class Obj {
public int state = 1;
}
package com.example.demo.locktest;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class ThreadA implements Runnable {
private int numA = 0;
private Obj obj;
private Lock lock;
private Condition condition;
public ThreadA(Obj obj, Lock lock, Condition condition) {
this.obj = obj;
this.lock = lock;
this.condition = condition;
}
//必须用while 来判断，
@Override
public void run() {
while (numA < 100) {
lock.lock();
try {
if (obj.state != 1) {
condition.await();
} else {
System.out.println(Thread.currentThread().getName() + " >>> " + numA);
Thread.sleep(100);
numA += 2;
obj.state = 2;
condition.signal();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
class ThreadB implements Runnable {
private int numB = 1;
private Obj obj;
private Lock lock;
private Condition condition;
public ThreadB(Obj obj, Lock lock, Condition condition) {
this.obj = obj;
this.lock = lock;
this.condition = condition;
}
@Override
public void run() {
while (numB < 100) {
lock.lock();
try {
if (obj.state != 2) {
condition.await();
} else {
System.out.println(Thread.currentThread().getName() + " >>> " + numB);
Thread.sleep(100);
numB += 2;
obj.state = 1;
condition.signal();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
public class ThreadDemo2 {
public static void main(String[] args) {
Obj obj = new Obj();
Lock lock = new ReentrantLock();
Condition d1 = lock.newCondition();
Runnable a = new ThreadA(obj, lock, d1);
Runnable b = new ThreadB(obj, lock, d1);
Thread t1 = new Thread(a, "Thread-A");
Thread t2 = new Thread(b, "Thread-B");
t1.start();
t2.start();
}
}