线程问题

线程问题

记一蠢事

在使用redisson分布式锁的时候，在单元测试测试这个锁的怎么运行的。
既然要测锁，就要用多个线程去测，一想到线程就使用Runable去创建了，因为可以使用内部类直接实现，感觉比较方便。

Runable runable = new Runnable() {
	@Override
	public void run() {
		...
	}
};

感觉还ok，然后

Runable runable1 = new Runnable() {
	@Override
	public void run() {
		...
	}
};

Runable runable2 = new Runnable() {
	@Override
	public void run() {
		...
	}
};

runable1.run();
runable2.run();

就当自己已经跑了两个线程。蠢哭了。。。
这样实际就是实现了两个类，并分别去调用了它的run()方法。没有新开启线程。

创建线程

既然给蠢到了，就看看实际线程是怎么创建的吧

extends Thread

public class MyThread extends Thread {
    
    @Override
    public void run() {
        ...
    }
    
    
    public static void main(String[] args) {
		MyThread mThread1=new MyThread();
		MyThread mThread2=new MyThread();
		MyThread mThread3=new MyThread();
		mThread1.start();
		mThread2.start();
		mThread3.start();
	}
}

implements Runable

public class MyThread implements Runable {
    
    @Override
    public void run() {
        ...
    }
    
    
    public static void main(String[] args) {
        MyThread mThread = new MyThread();
		Thread mThread1 = new Thread(mThread,"1");
		Thread mThread2 = new Thread(mThread,"2");
		Thread mThread3 = new Thread(mThread,"3");
		mThread1.start();
		mThread2.start();
		mThread3.start();
	}
}

public class Main {
    
    public static void main(String[] args) {
        
		Thread mThread1 = new Thread(() -> {
		    ...
		});
		Thread mThread1 = new Thread(() -> {
		    ...
		});
	    mThread1.start();
		mThread2.start();
	}
}

使用线程池 java.util.concurrent

public class Main {
    
    public static void main(String[] args) {
        
	    ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            executorService.execute(() -> {
                System.out.print("run..");
            });
        }
        executorService.shutdown();
	}
}

@Test单元测试 线程测试

若是在单元测试中测试线程问题，你可能会遇到一个问题。
run()方法中是写了输出的，但是控制台上什么都没有。
是因为单元测试在运行时是不管其他线程是否结束的，别的线程还在跑，它可能已经结束了，所以控制台上就没有输出了。
那么就要让测试线程等待其他线程都结束了，最后再结束。

CountDownLatch java.util.concurrent

public class Mian {

    public static void main(String[] args) throws InterruptedException {
        final int totalThread = 10;
        CountDownLatch countDownLatch = new CountDownLatch(totalThread);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < totalThread; i++) {
            executorService.execute(() -> {
                System.out.print("run..");
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        System.out.println("end");
        executorService.shutdown();
    }
}

每次调用 countDown() 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 await() 方法而在等待的线程就会被唤醒。这里是主线程调用了await() 方法，进入了等待。在计数为0时才会被唤醒。就达到了等待其他线程都结束再执行当前线程的目的。