遇到的一些多线程案例(1)

题目：使用多线程 将["123","456","789"] 这种字符串数组处理为["147","258","369"]形式输出

public String[] formart(String[] numbers) {
        ExecutorService ex = Executors.newFixedThreadPool(3);
        int size = numbers.length;
        String[][] pp = new String[size][ size];
        for (int i = 0; i < numbers.length; i++) {
            int k = i;
            ex.execute(() -> {
                System.out.println(Thread.currentThread().getName()+" 开始处理--------");
                char[] chars = numbers[k].toCharArray();
                for (int j = 0; j < chars.length; j++) {
                    pp[ j % size ][k] = String.valueOf(chars[ j ]);
                }
            });
        }
        ex.shutdown();
        String[] result = new String[size];
        for (int i = 0; i <pp.length ; i++) {
            StringBuffer sb = new StringBuffer();
            for (String s : pp[i]) {
                sb.append(s);
            }
            result[i] = sb.toString();
        }
        return result;
    }

问题：题目用让四个线程循环有序输出1,2,3,4    这儿有次测试发现如果index不用volatile修饰会卡死，详细说明请看：https://www.cnblogs.com/hetutu-5238/p/12188316.html

public class Demo2 {

    public static  volatile  int index = 0;
    public static void main(String[] args) {
        ThreadTest t1 = new ThreadTest("线程1" , 0);
        ThreadTest t2 = new ThreadTest("线程2" , 1);
        ThreadTest t3 = new ThreadTest("线程3" , 2);
        ThreadTest t4 = new ThreadTest("线程4" , 3);
        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
    static class ThreadTest extends Thread {
        private int i;
        public ThreadTest(String name , int i) {
            super(name);
            this.i = i;
        }
        @Override
        public void run() {
            while ( true ) {
                if ( (index & 3) == i ) {
                    System.out.println(Thread.currentThread().getName() + ":" + (i+1));
                    index++;
                }
            }
        }

    }

}

问题：有多个线程，代表的是行使的汽车，写一个红绿灯函数，等红灯亮时把所有的汽车线程都暂停，当绿灯亮时所有线程都启动起来

这儿先贴一个看到的比较好的答案，自己利用AQS实现锁，让所有汽车均可以通过这个锁类来控制通行。引用地址：https://segmentfault.com/q/1010000016621995/a-1020000016628980

这儿实现了tryAcquireShared方法通过判断红绿灯来决定是让其获取锁。这儿注意是实现共享锁方法所以下面的汽车均可以获得这把锁

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;

/**
 * 交通信号灯实现
 * 等红灯亮时把所有汽车线程都暂停，当绿灯亮时把所有线程都启动起来
 * @author ccr at 20181008
 */
public class TrafficLightLatch {
    private final class Sync extends AbstractQueuedSynchronizer {
        @Override
        protected int tryAcquireShared(int ignored) {
            return redLight == 0 ? 1 : -1;
        }

        @Override
        protected boolean tryReleaseShared(int arg) {
            return true;
        }
    }

    /**
     * 信号灯状态，非0代表红灯，0代表绿灯
     */
    volatile private int redLight;

    private Sync sync;

    /**
     * 初始化
     * @param redLight 初始红绿灯状态，非0代表红灯，0代表绿灯
     */
    public TrafficLightLatch(int redLight) {
        this.redLight = redLight;
        sync = new Sync();
    }

    /**
     * 红灯则等待，绿灯则直接通过
     * @throws InterruptedException
     */
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    /**
     * 切换为红灯
     */
    public void switchRed(){
        this.redLight = 1;
    }

    /**
     * 切换为绿灯
     */
    public void switchGreen() {
        this.redLight = 0;
        sync.releaseShared(0);
    }

    /**
     * 是否有线程等待
     */
    public boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

    /**
     * 等待中的线程
     * @return Collection
     */
    public Collection<Thread> getQueuedThreads() {
        return sync.getQueuedThreads();
    }

    public String getLightColor() {
        return redLight == 0 ? "绿灯" : "红灯";
    }

    //测试用例
    public static void main(String[] args) throws IOException, InterruptedException {
        //初始化交通信号灯为红灯
        TrafficLightLatch light = new TrafficLightLatch(1);
        List<Thread> threads = new ArrayList<>();
        //10个线程模拟车辆
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                while (!Thread.currentThread().isInterrupted()) {
                    //System.out.println(String.format("%s: 信号灯-%s",Thread.currentThread().getName(),light.getLightColor()));
                    try {
                        //绿灯直接通行，红灯阻塞等待
                        light.await();
                    } catch (InterruptedException e) {
                        //恢复中断
                        Thread.currentThread().interrupt();
                    }
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        //恢复中断
                        Thread.currentThread().interrupt();
                    }
                    System.out.println(String.format("%s: 信号灯-%s 通行",Thread.currentThread().getName(),light.getLightColor()));
                }
            });
            threads.add(thread);
            thread.start();
        }

        //等待输入命令切换交通信号灯
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String command;
        while ((command = reader.readLine()) != null) {
            if(command.equals("switchRed")) {
                light.switchRed();
                Thread.sleep(1000);
                System.out.println(String.format("等待线程数：%d",light.getQueuedThreads().size()));
            } else if(command.equals("switchGreen")) {
                light.switchGreen();
                Thread.sleep(500);
                System.out.println(String.format("等待线程数：%d",light.getQueuedThreads().size()));
            } else if (command.equals("stop")){
                System.out.println("terminating...");
                threads.forEach(Thread::interrupt);
                break;
            }
        }
    }
}

然后是我自己实现的代码

public class Demo4 {

    public static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    public static Lock readLock = readWriteLock.readLock();
    public static Lock writeLock = readWriteLock.writeLock();
    public static void main(String[] args) throws IOException {
        writeLock.lock();
        try {
            new CartThread("汽车A").start();
            new CartThread("汽车B").start();
            new CartThread("汽车C").start();
            System.out.println("请输入信号灯 red为红灯  green为绿灯");
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            String command;
            while ((command = reader.readLine()) != null) {
                if(command.equals("red")) {
                    System.out.println("红灯亮  所有车停止通行");
                    if(readWriteLock.getWriteHoldCount()==0)
                    writeLock.lock();
                }else if(command.equals("green")){
                    System.out.println("绿灯亮  所有车开始通行");
                    writeLock.unlock();
                }
            }
        }finally {
            writeLock.unlock();
        }
    }
    static class CartThread extends Thread{
        public CartThread(String name) {
            super(name);
        }
        @Override
        public void run() {
            while ( true ){
                readLock.lock();
                System.out.println(Thread.currentThread().getName()+"  :绿灯--发车");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }finally {
                    readLock.unlock();
                }
            }
        }
    }
}

以上均为个人的解决方案，如果有不对欢迎指正