JUC（java.util.concurrent），Java并发包，可以让Java更好地处理多线程并发问题。

传统线程创建方式

Thread

继承Thread类，重写其中的run方法，在run方法中编写任务代码：

1
2
3
4
5
6
7
8
9
10
11
12
13

public class Main {
    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();
        threadA.start();
    }
}

class ThreadA extends Thread{
    @Override
    public void run() {
        System.out.println("通过继承Thread的方式创建一个线程：ThreadA");
    }
}

start方法才是启动线程的方法，run方法是执行任务的方法，所以需要通过start方法来启动线程，线程会自动执行任务。

因为需要在Thread的run方法中编写任务代码，也就造成了线程与任务的耦合，一个线程与一个任务捆绑，不够灵活。

Runnable

我们是通过重写在run方法来提供任务的，如果我们看看Thread类就会发现，Thread类中的run方法也是重写的：

1
2

@Override
   public void run() {

Thread类实现了Runnable接口，重写了Runnable接口中的run方法：

1
2
3
4
5
6
7

@FunctionalInterface
public interface Runnable {
    /**
     * Runs this operation.
     */
    void run();
}

也就是说，其实run方法和Thread类是可以分开的，不捆绑在一起。

如果我们不重写Thread类的run方法，执行的就是Thread类自己的run方法逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@Override
public void run() {
    Runnable task = holder.task;  // 获取到task
    if (task != null) {
        Object bindings = scopedValueBindings(); // 获取线程上下文
        runWith(bindings, task); // 执行
    }
}

@Hidden
@ForceInline
private void runWith(Object bindings, Runnable op) {
    ensureMaterializedForStackWalk(bindings);
    op.run();
    Reference.reachabilityFence(bindings);
}

可以看到，此时，run方法需要先获取到一个Runnable对象，然后才能在runWith方法中调用Runnable对象的run方法来执行任务。

上面我们是通过无参构造函数来创建Thread对象的：

1

ThreadA threadA = new ThreadA();

而无参构造函数旁边刚好有一个可以传入Runnable对象的构造函数：

1
2
3
4
5
6
7

public Thread() {
    this(null, null, 0, null, 0, null);
}

public Thread(Runnable task) {
    this(null, null, 0, task, 0, null);
}

那么，我们只需要自己实现Runnable接口，重写run方法，就可以将任务与线程拆开啦：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Main {
    public static void main(String[] args) {
        ThreadB threadB = new ThreadB();
        Thread threadB1 = new Thread(threadB);
        Thread threadB2 = new Thread(threadB);
        threadB1.start();
        threadB2.start();
    }
}

class ThreadB implements Runnable{
    @Override
    public void run() {
        System.out.println("通过实现Runnable接口的方式创建一个线程：ThreadB");
    }
}

但是，这种创建线程的方式还有两个问题：

1. 拿不到返回值，start方法的返回值是void。

2. 线程内部异常不能被外层 try-catch 直接捕获：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

   public class Main { public static void main(String[] args) { ThreadB threadB = new ThreadB(); Thread threadB1 = new Thread(threadB); try { threadB1.start(); } catch (Exception e) { System.out.println("能捕捉到异常吗？"); } } } class ThreadB implements Runnable { @Override public void run() { // 构建异常 int i = 1 / 0; System.out.println("通过实现Runnable接口的方式创建一个线程：ThreadB"); } }

   执行时，线程threadB1内部发生的异常，如果线程threadB1内部不处理的话，外部线程无法捕捉到该异常并处理。

FutureTask

JUC提供了一个FutureTask类，可以用来获取线程执行结果。

FutureTask类实现了RunnableFuture接口：

1

public class FutureTask<V> implements RunnableFuture<V> {

RunnableFuture接口也继承了Runnable接口：

1
2
3

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

所以，FutureTask对象也可以用来构建一个Thread对象。那么，FutureTask类的run方法是如何实现的呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public void run() {
    if (state != NEW ||
        !RUNNER.compareAndSet(this, null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                result = c.call(); // 调用了Callable对象的call方法，并且获取到了结果result
                ran = true;
            } catch (Throwable ex) {
                result = null;
                ran = false;
                setException(ex);
            }
            if (ran)
                set(result);
        }
    } finally {
        // runner must be non-null until state is settled to
        // prevent concurrent calls to run()
        runner = null;
        // state must be re-read after nulling runner to prevent
        // leaked interrupts
        int s = state;
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

除了对线程状态的判断外（保证任务只执行一次、避免并发重复执行），关键就是调用了Callable对象的call方法，并且获取到了结果result。

而FutureTask类里也刚好有一个构造函数可以传递Callable对象：

1
2
3
4
5
6

public FutureTask(Callable<V> callable) {
     if (callable == null)
         throw new NullPointerException();
     this.callable = callable;
     this.state = NEW;       // ensure visibility of callable
 }

也就是说，我们需要在Callable对象中编写具体的任务。看看Callable接口：

1
2
3
4

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

有一个需要实现的call方法，并且是有返回值的！

那么，清晰了，我们需要先实现Callable接口，并重写call方法，然后传递给FutureTask对象，再将FutureTask对象传递给Thread对象，就可以啦！既可以拿到返回值，又可以捕捉到线程内部的异常：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Main {
    public static void main(String[] args) {
        FutureTask<Integer> futureTask = new FutureTask<>(new TaskC());
        new Thread(futureTask).start();
        try {
            System.out.println(futureTask.get());
        } catch (Exception e) {
            System.out.println("捕捉到异常");
        }
    }
}

class TaskC implements Callable<Integer> {
    @Override
    public Integer call() {
        return 1;
    }
}

CompletableFuture

如果有多个线程需要灵活合作的话，FutureTask用起来就不方便了。

JUC提供了CompletableFuture类，可以让我们灵活编排多个线程：

顺序执行

thenApplyAsync方法可以拿到前一个阶段的结果，然后开始执行当前任务：

1
2
3
4
5
6
7
8

public class Main {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> " future1 ok! ");
        CompletableFuture<String> future2 = future1.thenApplyAsync((result) -> result+" future2 ok! ");
        CompletableFuture<String> future3 = future2.thenApplyAsync((result) -> result+" future3 ok!");
        System.out.println(future3.join());
    }
}

阻塞等待

allOf方法可以组合多个任务，配合join/get方法阻塞等待所有的任务都执行完成：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Main {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> " future1 ok! ");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> " future2 ok! ");
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> " future3 ok! ");
        // 阻塞等待所有任务完成
        CompletableFuture<Void> all = CompletableFuture.allOf(future1, future2, future3);
        // 统一处理
        all.thenRun(() -> {
            String result1 = future1.join();
            String result2 = future2.join();
            String result3 = future3.join();
            System.out.println(result1);
            System.out.println(result2);
            System.out.println(result3);
        }).join(); // 阻塞等待处理完成
    }
}

anyOf方法可以组合多个任务，配合join/get方法阻塞等待任意一个任务先执行完成：

1
2
3
4
5
6
7
8
9
10

public class Main {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> " future1 ok! ");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> " future2 ok! ");
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> " future3 ok! ");
        // 阻塞等待一个任务完成
        CompletableFuture<Object> any = CompletableFuture.anyOf(future1, future2, future3);
        any.thenAccept(result -> System.out.println("First one：" + result)).join();
    }
}

线程池

CompletableFuture.supplyAsync方法还可以传入一个线程池，否则使用的就是公共线程池。使用公共线程池的话，可能会因为线程资源不足，影响公共线程池中的其他任务执行，所以推荐自定义一个线程池。

Executors

JUC提供了一个Executors类，可以帮助我们快捷创建线程池。

常用的有三个方法，分别创建一种常用的线程池：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// 创建只有一个线程的线程池  
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

// 创建有nThreads个线程的线程池  
 public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

// 创建可以动态扩容到Integer.MAX_VALUE个线程的线程池 
  public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

众所周知，阿里巴巴Java开发手册禁止通过Executors类来创建线程池，因为：

1. SingleThreadExecutor和FixedThreadPool配置的等待队列为LinkedBlockingQueue()，默认的长度是Integer.MAX_VALUE。允许大量等待任务，容易导致内存溢出（OOM）。
2. CachedThreadPool配置的最大线程数量为Integer.MAX_VALUE，允许创建大量的线程，也容易导致内存溢出（OOM）。

ThreadPoolExecutor

可以看到，Executors类里创建线程池的方法，其实是通过ThreadPoolExecutor类创建的，不过是帮我们配置了一些参数而已。如果要避开Executors类创建线程池的弊端，我们就需要通过ThreadPoolExecutor类来创建，并且自己配置参数。

ThreadPoolExecutor类的构造函数，有下面这几个参数：

• int corePoolSize：核心线程数，即使处于空闲状态也不会被销毁的线程
• int maximumPoolSize：线程池的最大线程数
• long keepAliveTime：当核心线程用完、任务等待队列用完、最大线程数未用完时，会创建新线程来处理任务，这些线程在空闲时的存活时间
• TimeUnit unit：keepAliveTime的单位
• BlockingQueue workQueue：任务等待队列，核心线程用完时，任务会在等待队列进行等待
• ThreadFactory threadFactory：创建线程时使用的工厂
• RejectedExecutionHandler handler：当核心线程用完、任务等待队列用完、最大线程数用完时，执行的任务拒绝策略

辅助工具

关于控制多个线程间的行为，JUC还提供了三个工具来辅助我们：

Semaphore

可以将Semaphore理解为一个信号量，可以设置持有一定数量的许可证，许可证被分发给某个线程后，只有该线程释放许可证后，其他线程才可获取：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class Main {
    public static void main(String[] args) {
        // 三个许可证
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 6; i++) {
            int temp = i;
            new Thread(() -> {
                boolean tried = false;
                try {
                    // 等待获取一个许可证
                    tried = semaphore.tryAcquire();
                    if (tried) {
                        // 模拟任务处理耗时
                        Thread.sleep(1000);
                        System.out.println(temp + "号：占用一个许可证");
                    }
                } catch (InterruptedException e) {
                    System.out.println("线程被中断");
                } finally {
                    // 释放一个许可证
                    if (tried) {
                        semaphore.release();
                        System.out.println(temp + "号：释放一个许可证");
                    }
                }
            }).start();
        }
    }
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12

0号：占用一个许可证
2号：占用一个许可证
1号：占用一个许可证
0号：释放一个许可证
2号：释放一个许可证
1号：释放一个许可证
3号：占用一个许可证
3号：释放一个许可证
5号：占用一个许可证
4号：占用一个许可证
4号：释放一个许可证
5号：释放一个许可证

可以看到，线程会阻塞等待获取许可证。

也就是说，可以用Semaphore来控制大量线程获取有限的资源。

CyclicBarrier

可以将CyclicBarrier理解为一个屏障，可以在任务中设置一个屏障，线程必须要等所有线程均抵达屏障处，才可继续向下执行任务：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class Main {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(4, () -> System.out.println("均抵达屏障处"));
        for (int i = 0; i < 4; i++) {
            int temp = i;
            new Thread(() -> {
                try {
                    // 模拟任务耗时
                    Thread.sleep(1000);
                    System.out.println(temp + "号已抵达屏障处");
                    // 等待其它线程抵达屏障处
                    cyclicBarrier.await();
                    // 继续任务
                    System.out.println(temp + "号继续任务");
                } catch (InterruptedException | BrokenBarrierException e) {
                    throw new RuntimeException(e);
                }
            }).start();
        }
    }
}

结果：

1
2
3
4
5
6
7
8
9

2号已抵达屏障处
3号已抵达屏障处
1号已抵达屏障处
0号已抵达屏障处
均抵达屏障处
0号继续任务
2号继续任务
3号继续任务
1号继续任务

可以看到，每个线程都会等待其它线程抵达屏障处，然后才会继续执行任务。

也就是说，可以用CyclicBarrier来控制多个线程间互相等待。

CountDownLatch

可以将CountDownLatch理解为一个计数器，可以控制一个线程必须阻塞等待计数器归零，才能继续执行任务：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public class Main {
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(4);
        for (int i = 0; i < 4; i++) {
            int temp = i;
            new Thread(() -> {
                try {
                    // 模拟任务耗时
                    Thread.sleep(1000);
                    System.out.println(temp + "号执行完成");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    // 减少计数
                    countDownLatch.countDown();
                }
            }).start();
        }
        try {
            // 阻塞等待计数器归零
            countDownLatch.await();
            System.out.println("全部执行完成");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

结果：

1
2
3
4
5

2号执行完成
1号执行完成
3号执行完成
0号执行完成
全部执行完成

可以看到，我们控制了main线程等待其他线程减少计数器，然后main线程才能继续执行任务。

也就是说，CountDownLatch可以用来控制一个线程等待其它线程。

原子类

前面我们介绍了JUC提供的很多工具，可以帮助我们很方便地构建多线程。但是，还无法解决多线程访问共享数据的并发安全问题。JUC在atomic包下提供了一些原子类，原子类封装了一些并发安全的方法。

常用的原子类有：AtomicBoolean、AtomicInteger、AtomicLong：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Main {
    public static void main(String[] args) throws InterruptedException {
        AtomicInteger atomicInteger = new AtomicInteger();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                int get = atomicInteger.incrementAndGet();
                System.out.println(get);
            }).start();
        }
        // 等待线程执行完成
        Thread.sleep(1000);
        System.out.println("最终:" + atomicInteger.get());
    }
}

原子类内部对值添加了volatile关键字：

1

private volatile int value;

这样保证了值的可见性，一个线程修改后，其它线程立刻能看见。

此外，对值的修改使用了Unsafe类下的CAS方法：

1
2
3
4
5

private static final Unsafe U = Unsafe.getUnsafe();  

public final boolean compareAndSet(int expectedValue, int newValue) {
        return U.compareAndSetInt(this, VALUE, expectedValue, newValue);
    }

CAS方法是利用JVM调用CPU级原子指令来保证并发安全性的。

所以，原子类只能保证单次方法调用是并发安全的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class Main {
    public static void main(String[] args) throws InterruptedException {
        AtomicInteger atomicInteger = new AtomicInteger();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                // 一个原子类的两次操作就不是并发安全的了
                if (atomicInteger.get() == 0) {
                    try {
                        Thread.sleep(1000);
                        atomicInteger.incrementAndGet();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }).start();
        }
        // 等待线程执行完成
        Thread.sleep(2000);
        System.out.println("最终:" + atomicInteger.get());
    }
}

集合类

JUC还提供了一些并发安全的集合类，常用的有ConcurrentHashMap、CopyOnWriteArrayList、CopyOnWriteArraySet、ArrayBlockingQueue：

1
2
3
4
5
6
7
8
9
10
11

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("a",0);
        for (int i = 0; i < 10; i++) {
            new Thread(()-> map.compute("a",(k, v)->v+1)).start();
        }
        Thread.sleep(1000);
        System.out.println(map.get("a"));
    }
}

JUC提供的集合类，并不都采用同一种机制来实现并发安全性。

ConcurrentHashMap是通过CAS结合synchronized来实现，详情参考本人另一篇文章：https://blog.csdn.net/Uncommen/article/details/144174135。

CopyOnWriteArrayList在写操作时会先加synchronized锁，然后将原数组复制一份，在新数组上修改，再将新数组赋给元素组。这样，读操作即使不加锁，结合volatile就可以保证要么读到旧数组，要么读到新数组，绝不会读到中间脏数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

private transient volatile Object[] array;

public E get(int index) {
        return elementAt(getArray(), index);
    }

public E set(int index, E element) {
        synchronized (lock) {
            Object[] es = getArray();
            E oldValue = elementAt(es, index);

            if (oldValue != element) {
                es = es.clone();
                es[index] = element;
            }
            // Ensure volatile write semantics even when oldvalue == element
            setArray(es);
            return oldValue;
        }
    }

CopyOnWriteArraySet跟CopyOnWriteArrayList差不多，只是需要判断重复值。会先不加锁判断重复情况，提高效率，如果没有重复值，再加锁去进一步操作，加了锁后还需要再判断一次重复值，避免被其它线程趁方法调用间隙插入了重复值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public boolean addIfAbsent(E e) {
    Object[] snapshot = getArray();
    return indexOfRange(e, snapshot, 0, snapshot.length) < 0
        && addIfAbsent(e, snapshot);
}

/**
 * A version of addIfAbsent using the strong hint that given
 * recent snapshot does not contain e.
 */
private boolean addIfAbsent(E e, Object[] snapshot) {
    synchronized (lock) {
        Object[] current = getArray();
        int len = current.length;
        if (snapshot != current) {
            // Optimize for lost race to another addXXX operation
            int common = Math.min(snapshot.length, len);
            for (int i = 0; i < common; i++)
                if (current[i] != snapshot[i]
                    && Objects.equals(e, current[i]))
                    return false;
            if (indexOfRange(e, current, common, len) >= 0)
                    return false;
        }
        Object[] newElements = Arrays.copyOf(current, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    }
}

ArrayBlockingQueue是对写操作加ReentrantLock锁实现并发安全性，并且通Condition来实现等待队列空余：

1
2
3
4
5
6
7
8
9
10
11
12

public void put(E e) throws InterruptedException {
        Objects.requireNonNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == items.length)
                notFull.await();
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }

锁

Synchronized

既然是通过加synchronized锁来保证并发安全性的，那我们完全可以自己操作synchronized锁来保证一段操作的并发安全性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class Main {
    private static int count = 0;
    private static final Object LOCK = new Object();

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                synchronized (LOCK) {
                    if (count == 0) {
                        try {
                            Thread.sleep(500);
                            count++;
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }).start();
        }
        Thread.sleep(1000);
        System.out.println(count);
    }
}

关于synchronized锁的详细讲解，可以阅读本人的另一篇文章：https://blog.csdn.net/Uncommen/article/details/152095400

Lock

synchronized锁的用法非常简单，可读性强，不需要我们手动解锁，但同时也缺乏了灵活性。如果我们想更灵活的控制加锁解锁，JUC为我们提供了Lock锁。

Lock是一个接口，代表一类锁，常用的是ReentrantLock可重入锁：

1

public class ReentrantLock implements Lock, java.io.Serializable {

简单的使用，手动加锁解锁，需要在finally中保证锁的释放，避免死锁：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public class Main {
    private static int count = 0;
    private static final Lock LOCK = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    LOCK.lock();
                    if (count == 0) {
                        try {
                            Thread.sleep(500);
                            count++;
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                } finally {
                    LOCK.unlock();
                }
            }).start();
        }
        Thread.sleep(1000);
        System.out.println(count);
    }
}

可以在规定时间内尝试获取锁，而不是一直等着：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

public class Main {
    private static int count = 0;
    private static final Lock LOCK = new ReentrantLock();

    public static void main(String[] args) throws Exception {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                boolean tried = false;
                try {
                    // 尝试获取锁，超过3秒没获取到锁时返回false
                    tried = LOCK.tryLock(3, TimeUnit.SECONDS);
                    if (tried && count == 0) {
                        Thread.sleep(500);
                        count++;
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    if (tried) {
                        LOCK.unlock();
                    }
                }
            }).start();
        }
        Thread.sleep(5000);
        System.out.println(count);
    }
}

ReentrantLock默认是非公平锁，可以传参设置为公平锁（讲究先来后到）：

1
2
3

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

如果我们想要控制两个线程交替执行，形成类似生产者消费者模型的话，对于synchronized锁，由于是利用Object类提供的wait方法和notifyAll方法，所以生产者和消费者相当于共用同一个等待队列，notifyAll方法会将所有等待线程唤醒：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public class Main {
    private static int count = 0;
    private static final Object LOCK = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                synchronized (LOCK) {
                    try {
                        while (count > 0) {
                            LOCK.wait();
                        }
                        count++;
                        System.out.println(Thread.currentThread().getName() + ":" + count);
                        LOCK.notifyAll();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }, "生产者").start();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                synchronized (LOCK) {
                    try {
                        while (count < 1) {
                            LOCK.wait();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName() + ":" + count);
                        LOCK.notifyAll();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }, "消费者").start();
    }
}

但是，JUC为我们提供了Condition，可以让我们为生产者和消费者提供不同的等待队列：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

public class Main {
    public static void main(String[] args) {
        Pc pc = new Pc();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                pc.publish();
            }
        }, "生产者").start();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                pc.consume();
            }
        }, "消费者").start();
    }
}

class Pc {
    Lock lock = new ReentrantLock();
    Condition publisher = lock.newCondition();
    Condition consumer = lock.newCondition();
    int count = 0;

    public void publish() {
        try {
            lock.lock();
            while (count > 0) {
                publisher.await();
            }
            System.out.println(Thread.currentThread().getName() + ":" + ++count);
            consumer.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void consume() {
        try {
            lock.lock();
            while (count < 1) {
                consumer.await();
            }
            System.out.println(Thread.currentThread().getName() + ":" + --count);
            publisher.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

但是，上面的所有情况，都是无论读数据还是写数据，都用同一把锁，多个读操作间仍然需要竞争锁，这是不合理的，读操作完全可以单独使用一把共享锁，而不是与写操作共用一把互斥锁。

没关系，JUC为我们提供了一个ReentrantReadWriteLock可重入读写锁：

可以将共享的读锁与互斥的写锁分开：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

public class Main {
    public static void main(String[] args) {
        Pc pc = new Pc();
        for (int i = 0; i < 5; i++) {
            new Thread(pc::read).start();
        }
        for (int i = 0; i < 5; i++) {
            new Thread(pc::write).start();
        }
    }
}

class Pc {
    ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    Lock readLock = lock.readLock();
    Lock writeLock = lock.writeLock();
    int count = 0;

    public void read() {
        try {
            readLock.lock();
            System.out.println("获取到读锁");
            Thread.sleep(1000);
            System.out.println("读到：" + count);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("释放读锁");
            readLock.unlock();
        }
    }

    public void write() {
        try {
            writeLock.lock();
            System.out.println("获取到写锁");
            System.out.println("写入:" + ++count);
        } finally {
            System.out.println("释放写锁");
            writeLock.unlock();
        }
    }
}

读读间共享，读写、写写间互斥。

众所周知，在计算机中，数据主要存储在硬盘中，但是，硬盘的读写速度相对于CPU执行指令的速度太慢太慢了，于是，我们会添加读写速度更快的内存（因为内存读写速度比较快，所以也比较贵，如果直接用内存取代磁盘的话，大部分人都承担不起这个价钱）来作为硬盘的缓存。数据先从磁盘读取到内存中，内存可以较高的效率与CPU交互，这样也就提高了计算机的效率。

当内存中的数据更新时，需要写回到磁盘中，这需要时间，也就导致了在这段时间内，磁盘与内存间数据的不一致现象。

当有多个线程时，有的现场从内存中读值，有的线程从磁盘中读值，或者多个线程同时修改内存中的值，结果导致操作被覆盖，等等。此外，现代编译器为了提高程序运行效率，会对代码进行重排序，现代CPU为了提高指令运行效率，也会对指令进行重排序。这些情况都可能导致多线程共享数据数据的不一致现象（重排序只保证单线程安全）。

这就需要一个规范（称之为“内存模型”）来解决这些混乱的情况，不同操作系统会有不同的规范。Java因为要保证跨平台性，所以不能直接使用某个操作系统现成的规范，需要有自己的规范，由JVM负责适配各操作系统。Java的这套规范，就叫做JMM（Java Memory Model ：Java内存模型）。

JMM

JMM是用来解决Java并发编程问题的一个规范。

JMM不是具体的技术实现，不同版本的Java可以用不同的方式实现这个规范。

JMM也利用了缓存机制来提效，所有共享变量都存在主内存中（可能是用操作系统的内存来实现），线程需要将共享变量读取到自己独立的工作内存中（可能是用操作系统的CPU高速缓存来实现），操作完成后再写回主内存中。

想要保证并发编程的安全性，就要解决以下问题：

• 一个线程对共享变量的操作是个不可分割的整体，不可中断：

  错误情况：

  1 2 3 4 5 6 7 8

  初始 i = 0 线程A: 读 i -> 0 线程B: 读 i -> 0 线程A: i+1 -> 1 线程B: i+1 -> 1 线程A: 写回 i=1 线程B: 写回 i=1 最终 i=1 （本该是2）

  正确情况：

  1 2 3 4 5 6 7 8 9 10 11

  初始 i = 0 --------------- | 线程A: 读 i -> 0 不可分割的整体| 线程A: i+1 -> 1 | 线程A: 写回 i=1 --------------- | 线程B: 读 i -> 1 不可分割的整体| 线程B: i+1 -> 2 | 线程B: 写回 i=2 --------------- 最终 i=2

  因为线程A对i的操作是个不可分割的整体，所以线程B不能穿插进去。

• 一个线程对共享数据的操作结果可以立刻被其它线程看见：

  对于上面的情况，可能线程A写回i=1到主存中，但是，

  可能主存也有多级缓存，线程A写回到2级主存中，但线程B却从1级主存中读值；

  可能主存虽然拿到线程A写回的新值了，但是还没来得及更新旧值；

  可能线程B之前缓存过旧值，这次没从主存中读取，而是从自己的缓存中读取。

  所以，必须要保证线程A写回的值，线程B能够立即看见。

• 一个线程对共享数据的操作的重排序不能影响其他线程：

  试想这种情况：

  1 2 3 4 5 6 7 8 9

  初始 i = 0 线程A: 读 i -> 0 线程A: i=1 线程A: i=2 线程A: 写回 i=2 线程B: 读 i -> 2 线程B: i+1 -> 3 线程B: 写回 i=3 最终 i=3

  如果发生指令重排序，将线程A: i=1和线程A: i=2的顺序反过来执行，那么最终结果就是2。

总结一下，如果想要保证并发编程的安全性，就需要保证三大特性：

• 原子性：一系列操作组成不可分割的整体，不可被中断。

• 可见性：一个线程对共享变量的修改，其它线程可以立即看见。

• 有序性：指令重排序不能影响多线程的结果。

那么，Java通常是如何实现这三大特性的呢?

原子性

在Java中，可以通过synchronized或Lock加锁来实现原子性：

加锁的代码块，在同一时刻只有一个线程能访问。其他线程必须等待锁被释放后，并且尝试获取到锁后，才能访问该代码块。也就不会被其它线程穿插进来，中断执行。

也可以通过原子类来实现原子性：

原子类（如：AtomicInteger、AtomicLong）利用CPU提供的原子级指令*CAS（Compare And Swap）*来实现原子性，CPU会保证不会有其它指令穿插进来。

可见性

用volatile修饰共享变量，可以保证被修改的共享变量立刻写回主存，读取时只从主存中读取。

因为原子类内部也是用volatile来修饰变量，所以原子类也可以保证可见性。

但是，volatile只能修饰单个变量，所以也只能保证单个变量的可见性。如果要组合操作多个共享变量，需要使用synchronized或Lock加锁，他们也可以保证被修改的共享变量立刻写回主存，读取时只从主存中读取。

有序性

JMM有一个happens-before原则，要求某个操作必须发生在某个操作之前，从而限制了指令重排序，保证了有序性。

在Java中，volatile、synchronized、Lock都实现了happens-before原则，会在操作前后加入内存屏障，不允许内存屏障前的指令和内存屏障后的乱序，从而保证有序性。

文章由本人阅读Spring Cloud Alibaba官方文档时总结而成，一切以官方描述为准。

项目源码：https://github.com/WanAnUncommon/SpringCloudAlibabaDemo

Spring Cloud 是什么？

我们知道，如果要实现一个分布式系统，需要引入各种组件，来实现网关、服务发现、配置中心、限流等功能。如果每一个组件都需要我们手动下载、编写配置文件、适配原生API，那就太麻烦了。既然一个单体项目可以通过Spring Boot整合各种组件实现快速开发，那么，自然可以有一个框架整合网关、服务发现、配置中心、限流等组件来实现分布式项目的快速开发。Spring Cloud应运而生。

Spring Cloud是一套规范，主流的微服务组件都遵循了这套规范，我们就可以便捷的通过Spring Cloud来统筹一个分布式系统所需要的网关、服务发现、配置中心、限流等组件。

Spring Cloud Alibaba 是什么？

Spring Cloud致力于统筹所有的微服务组件，想要为所有的微服务组件都提供同一个开发规范，但是，实际项目开发中，往往需要具体问题具体分析，针对特定的场景，对某些组件进行优化。

Netflix开发了Spring Cloud Netflix，主要针对Eureka、Ribbon、Feign、Hystrix等组件进行了优化。但是慢慢的，Netflix不再维护Spring Cloud Netflix了。

Alibaba开发了Spring Cloud Alibaba，主要针对Nacos、Sentinel、Seata等组件进行了优化。Spring Cloud Alibaba慢慢的取代了Spring Cloud Netflix，成为目前主流的分布系统开发框架。

Spring Cloud Alibaba也是国内首个进入Spring社区的开源项目。2018年7月，Spring Cloud Alibaba正式开源，并进入Spring Cloud孵化器中孵化；2019年7月，Spring Cloud官方宣布Spring Cloud Alibaba毕业，并将仓库迁移到Alibaba Github OSS下。

服务发现与配置中心：Nacos

“服务发现”是什么？

对于一个单体项目，一个方法想要使用另一个方法，只需要正常的方法调用就行。但是，对于一个分布式系统，两个方法可能分布在不同的服务器，那么一个方法就需要先知道另一个方法的IP、端口等基本信息才能进行调用。如果直接将其他服务器上方法的基本信息记录在自己的服务器上，那么一个分布式系统的模块间的耦合度就太高了，不便于维护。

所以，需要有一个统一的服务，不同模块将自己需要暴露出去的接口信息注册到这个服务中，那么，一个模块中的方法想要调用其他模块中的方法时，只需要到这个服务中去查询一下，就可以得到IP、端口等信息，然后就可以去调用方法了。这个服务就叫“服务发现”，或者“服务注册与发现”。

Spring Cloud Alibaba通过Nacos实现服务发现。

如上图所示，所有的微服务应用在启动过程中会将自身包含服务名称、主机IP地址和端口号等信息发送到注册中心中，然后服务调用方根据服务名称到注册中心中查找对应服务的所有实例IP地址和端口号来进行服务调用。从而让分散的微服务系统之间能像一个整体一样进行交互。

“配置中心”是什么？

一个项目中，会有很多配置信息，例如数据库连接字符串、日志级别等，如果想要更换数据库，就需要修改配置文件，然后重新打包、部署项目。对于单体项目，还可以忍受，但是对于一个分布式项目，可能涉及多个模块，每个模块都需要重新打包、部署，这就太不利于维护了。

所以，需要有一个统一的服务，将项目中主要的配置信息交给这个服务来维护，项目动态地从该服务中拉取配置信息。这个服务就叫“配置中心”。

Spring Cloud Alibaba通过Nacos实现配置中心。

配置中心在分布式场景中可以帮助解决以下问题：

1. 管理应用程序配置：当有大量应用程序需要管理时，手动维护配置文件会变得非常困难。分布式配置中心提供了一个集中管理和发布配置信息的解决方案。
2. 环境隔离：在开发、测试和生产等不同环境中，应用程序的配置信息往往都会有不同。使用分布式配置中心，可以轻松的管理和分发不同环境下的配置信息。
3. 提高程序安全性：将配置信息存储在代码库或应用程序文件中可能会导致安全风险，因为这些信息可能会被意外地泄露或被恶意攻击者利用。使用分布式配置，可以将配置信息加密和保护，并且可以进行访问权限控制。
4. 动态更新配置：在应用程序运行时，可能需要动态地更新配置信息，以便应用程序可以及时响应变化。使用分布式配置中心，可以在运行时动态更新配置信息，而无需重新启动应用程序。

Nacos实战

Nacos /nɑ:k əʊs/ （Dynamic Naming and Configuration Service）是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。

本地安装Nacos

1. 在Nacos官网下载稳定版本的二进制包（这里下载的是Spring Cloud Alibaba 2022.x推荐

   的2.2.3版本）：

   

2. 下载完成后，解压缩对应的nacos-server-2.2.3.zip压缩包

3. 在解压缩后的nacos/conf/application.properties文件中配置数据源及鉴权信息：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

   #*************** Config Module Related Configurations ***************# ### If use MySQL as datasource: ### Deprecated configuration property, it is recommended to use `spring.sql.init.platform` replaced. # spring.datasource.platform=mysql spring.sql.init.platform=mysql ### Count of DB: db.num=1 ### Connect URL of DB: db.url.0=jdbc:mysql://127.0.0.1:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC db.user.0=root db.password.0=2469 ### Connection pool configuration: hikariCP db.pool.config.connectionTimeout=30000 db.pool.config.validationTimeout=10000 db.pool.config.maximumPoolSize=20 db.pool.config.minimumIdle=2

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

   ### The auth system to use, currently only 'nacos' and 'ldap' is supported: nacos.core.auth.system.type=nacos ### If turn on auth system: nacos.core.auth.enabled=true ### Turn on/off caching of auth information. By turning on this switch, the update of auth information would have a 15 seconds delay. nacos.core.auth.caching.enabled=true ### Since 1.4.1, Turn on/off white auth for user-agent: nacos-server, only for upgrade from old version. nacos.core.auth.enable.userAgentAuthWhite=false ### Since 1.4.1, worked when nacos.core.auth.enabled=true and nacos.core.auth.enable.userAgentAuthWhite=false. ### The two properties is the white list for auth and used by identity the request from other server. nacos.core.auth.server.identity.key=nacos nacos.core.auth.server.identity.value=nacos ### worked when nacos.core.auth.system.type=nacos ### The token expiration in seconds: nacos.core.auth.plugin.nacos.token.cache.enable=false nacos.core.auth.plugin.nacos.token.expire.seconds=18000 ### The default token (Base64 String): nacos.core.auth.plugin.nacos.token.secret.key=SecretKey012345678901234567890123456789012345678901234567890123456789

4. 在连接的MySQL数据库中创建nacos库，并且在该库内执行nacos/conf/mysql-schema.sql文件，进行数据库初始化

5. 然后在nacos/bin目录下通过cmd命令行运行startup.cmd -m standalone启动Nacos单机模式

   

6. 运行成功后，可以在浏览器访问Nacos控制台：http://127.0.0.1:8848

   默认账号：nacos 密码：nacos

   

项目接入Nacos Config

1. 新建一个Spring Boot项目：

   

   我的idea最低支持SpringBoot3.5.10，但是Spring Cloud Alibaba最多支持SpringBoot3.0.2，所以在pom.xml文件中改为3.0.2版本

2. 引入Spring Cloud Alibaba依赖：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

   <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.example</groupId> <artifactId>SpringCloudAlibabaDemo</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>pom</packaging> <properties> <spring-boot.version>3.0.2</spring-boot.version> <spring-cloud-alibaba.version>2022.0.0.0</spring-cloud-alibaba.version> <spring-cloud.version>2022.0.0</spring-cloud.version> <java.version>20</java.version> </properties> <modules> <module>NacosConfig</module> </modules> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-dependencies</artifactId> <version>${spring-boot.version}</version> <type>pom</type> <scope>import</scope> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>${spring-cloud.version}</version> <type>pom</type> <scope>import</scope> </dependency> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-alibaba-dependencies</artifactId> <version>${spring-cloud-alibaba.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <build> <pluginManagement> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <version>${spring-boot.version}</version> </plugin> </plugins> </pluginManagement> </build> </project>

   删除src目录。

   创建子模块NacosConfig。

   在NacosConfig模块的pom.xml文件中添加nacos-config的依赖：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

   <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>com.example</groupId> <artifactId>SpringCloudAlibabaDemo</artifactId> <version>0.0.1-SNAPSHOT</version> <relativePath>../pom.xml</relativePath> </parent> <artifactId>NacosConfig</artifactId> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>

   在resources/application.yaml中配置nacos-config：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   spring: application: name: NacosConfig cloud: nacos: serverAddr: 127.0.0.1:8848 username: nacos password: nacos config: import: - nacos:nacos-config-example.properties?refreshEnabled=true server: port: 18084 management: endpoints: web: exposure: include: "*"

3. 在Nacos控制台中添加配置信息：nacos-config-example.properties

   1 2 3 4

   spring.cloud.nacos.config.serveraddr=127.0.0.1:8848 spring.cloud.nacos.config.prefix=PREFIX spring.cloud.nacos.config.group=GROUP spring.cloud.nacos.config.namespace=NAMESPACE

   

4. 运行项目后可见，配置加载成功：

   

   在Nacos控制台中修改nacos-config-example.properties的配置信息后，项目动态识别更新：

   

项目接入Nacos Discovery

1. 新建一个NacosProvider子模块，在pom.xml文件中添加依赖：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

   <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>com.example</groupId> <artifactId>SpringCloudAlibabaDemo</artifactId> <version>0.0.1-SNAPSHOT</version> </parent> <artifactId>NacosProvider</artifactId> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>

2. 在NacosProvider模块的application.yml文件中添加配置：

   1 2 3 4 5 6 7 8 9 10 11

   spring: application: name: NacosProvider cloud: nacos: discovery: server-addr: 127.0.0.1:8848 username: nacos password: nacos server: port: 18085

3. 在NacosProvider模块的启动类上添加注解@EnableDiscoveryClient，开启Nacos服务发现：

   1 2 3 4 5 6 7 8 9 10 11 12 13

   package com.example; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.client.discovery.EnableDiscoveryClient; @SpringBootApplication @EnableDiscoveryClient public class NacosProviderApplication { public static void main(String[] args) { SpringApplication.run(NacosProviderApplication.class, args); } }

   添加这个注解后，这个项目就成为了服务的提供者。

4. 在NacosProvider模块提供一个接口，便于后面消费者调用：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   package com.example.controller; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController @RequestMapping("/provider") public class Provider { @GetMapping("/hello") public String hello() { return "hello nacos"; } }

5. 启动NacosProvider项目后，可以在Nacos控制台看见服务已被注册：

   

6. 我们新建一个NacosConsumer子模块，在pom.xml中添加依赖：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

   <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>com.example</groupId> <artifactId>SpringCloudAlibabaDemo</artifactId> <version>0.0.1-SNAPSHOT</version> </parent> <artifactId>NacosConsumer</artifactId> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-loadbalancer</artifactId> </dependency> </dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>

   在application.yml文件中添加配置：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   spring: application: name: NacosConsumer cloud: nacos: discovery: server-addr: 127.0.0.1:8848 username: nacos password: nacos loadbalancer: nacos: enabled: true server: port: 18086

7. 在NacosConsumer模块的启动类上添加注解@EnableDiscoveryClient，开启Nacos服务发现，

   添加注解@EnableFeignClients开启Feign：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   package example; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.client.discovery.EnableDiscoveryClient; import org.springframework.cloud.openfeign.EnableFeignClients; @SpringBootApplication @EnableDiscoveryClient @EnableFeignClients public class NacosConsumerApplication { public static void main(String[] args) { SpringApplication.run(NacosConsumerApplication.class, args); } }

8. 在NacosConsumer模块配置一个 FeignClient：

   1 2 3 4 5 6 7 8 9 10 11 12

   package example.api; import org.springframework.cloud.openfeign.FeignClient; import org.springframework.web.bind.annotation.GetMapping; // value 对应 Nacos 中的服务名 @FeignClient(value = "NacosProvider", path = "/provider") public interface UserClient { @GetMapping("/hello") String hello(); }

   就可以正常使用这个接口了：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   package example.controller; import example.api.UserClient; import jakarta.annotation.Resource; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController @RequestMapping("/consumer") public class Consumer { @Resource private UserClient userClient; @GetMapping("/hello") public String hello() { return userClient.hello(); } }

9. 启动NacosProvider和NacosConsumer，在浏览器访问http://127.0.0.1:18086/consumer/hello，正确返回了`hello nacos`字符串。

分布式事务：Seata

分布式事务是什么？

我们知道，事务具有四大特性：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）。系统需要通过对原子性、隔离性以及持久性的权衡，来保障数据的一致性。

区别于单体项目，分布式事务的难点在于，一个事务涉及的数据需要在多个模块、多台服务器上进行操作。数据传输的不确定性，造成了分布式事务的复杂性。

Seata应运而生。

Seata实战

启动Seata

1. 在Seata官网下载Spring Cloud Alibaba对应版本的Seata 1.7.0二进制压缩包：

   

2. 修改Seata配置文件。

   seata/conf/application.example.yml是参考模版，需要在seata/conf/application.yml提供自己的配置信息。我这里已经改好了，可以参考注解修改：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

   server: port: 7091 # 默认端口 spring: application: name: seata-server # 默认服务名称 logging: config: classpath:logback-spring.xml # 日志配置 file: path: ${user.home}/logs/seata extend: logstash-appender: destination: 127.0.0.1:4560 kafka-appender: bootstrap-servers: 127.0.0.1:9092 topic: logback_to_logstash console: # 控制台的用户名密码 user: username: seata password: seata seata: config: # support: nacos 、 consul 、 apollo 、 zk 、 etcd3 type: nacos # 指定nacos作为配置中心 nacos: server-addr: 127.0.0.1:8848 # nacos的地址 namespace: group: SEATA_GROUP username: nacos # nacos控制台的用户名密码 password: nacos ##if use MSE Nacos with auth, mutex with username/password attribute #access-key: "" #secret-key: "" data-id: seataServer.properties registry: # support: nacos 、 eureka 、 redis 、 zk 、 consul 、 etcd3 、 sofa type: nacos # 指定nacos作为注册中心 preferred-networks: 30.240.* nacos: application: seata-server server-addr: 127.0.0.1:8848 group: SEATA_GROUP namespace: cluster: default username: nacos password: nacos ##if use MSE Nacos with auth, mutex with username/password attribute #access-key: "" #secret-key: "" server: service-port: 8091 #If not configured, the default is '${server.port} + 1000' seata服务的配置 我这边都用的模版的默认配置 max-commit-retry-timeout: -1 max-rollback-retry-timeout: -1 rollback-retry-timeout-unlock-enable: false enable-check-auth: true enable-parallel-request-handle: true retry-dead-threshold: 130000 xaer-nota-retry-timeout: 60000 vgroup-mapping: fsp_tx_group: default recovery: handle-all-session-period: 1000 undo: log-save-days: 7 log-delete-period: 86400000 session: branch-async-queue-size: 5000 #branch async remove queue size enable-branch-async-remove: false #enable to asynchronous remove branchSession store: # support: file 、 db 、 redis seata数据的保存方式 mode: db # 这边后续考虑高可用 选择使用数据库保存 默认是file文件 db: datasource: druid db-type: mysql driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://127.0.0.1:3308/seata?rewriteBatchedStatements=true # 自己的MySQL地址，及用户名密码 user: root password: 2469 min-conn: 5 max-conn: 100 global-table: global_table branch-table: branch_table lock-table: lock_table distributed-lock-table: distributed_lock query-limit: 100 max-wait: 5000 security: secretKey: SeataSecretKey0c382ef121d778043159209298fd40bf3850a017 tokenValidityInMilliseconds: 1800000 ignore: urls: /,/**/*.css,/**/*.js,/**/*.html,/**/*.map,/**/*.svg,/**/*.png,/**/*.ico,/console-fe/public/**,/api/v1/auth/login

3. 在seata/lib/jdbc下，会有多个mySQL驱动版本，留下自己的版本，删除其它：

   

4. 在MySQL中创建数据库seata，执行seata/script/server/db/mysql.sql文件，创建4张表：global_table、branch_table、lock_table、distributed_lock。

   执行下面的sql，创建 undo_log 表：

   1 2 3 4 5 6 7 8 9 10 11 12 13

   CREATE TABLE `undo_log` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `branch_id` bigint(20) NOT NULL, `xid` varchar(100) NOT NULL, `context` varchar(128) NOT NULL, `rollback_info` longblob NOT NULL, `log_status` int(11) NOT NULL, `log_created` datetime NOT NULL, `log_modified` datetime NOT NULL, `ext` varchar(100) DEFAULT NULL, PRIMARY KEY (`id`), UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

5. 在nacos/bin目录下通过cmd命令行运行startup.cmd -m standalone启动Nacos单机模式。

   然后运行seata/bin/seata-server.bat文件，启动Seata Server：

   

   成功访问http://127.0.0.1:7091/，账号/密码：seata/seata

   

   访问Nacos控制台可以看见seata-server已成功注册：