两道多线程打印题目

1.每个线程打印不同的字符

public class ThreadPrint
{
    public static void main(String[] args)
        throws InterruptedException
    {
        String str = "ABCD";
        int index = 4;
        Character c;
        Map<Character, MyLock> locks = new HashMap<>();
        MyLock lock = new MyLock();
        for (int i = 0; i < index; i++)
        {
            for (int j = 0; j < str.length(); j++)
            {
                c = str.charAt(j);
                if (null == locks.get(c))
                {
                    lock = new MyLock();
                    lock.setCountDownLatch(new CountDownLatch(1));
                    new Thread(new MyRunnable(c, lock)).start();
                    locks.put(c, lock);
                    lock.getCountDownLatch().await();
                }
                else
                {
                    lock = locks.get(c);
                    lock.setCountDownLatch(new CountDownLatch(1));
                    synchronized (lock)
                    {
                        locks.get(c).notify();
                    }
                    lock.getCountDownLatch().await();
                }
            }
        }
        for (Entry<Character, MyLock> entry : locks.entrySet())
        {
            synchronized (entry.getValue())
            {
                entry.getValue().setEnd(true);
                entry.getValue().notify();
            }
        }
    }

    static class MyLock
    {
        private boolean end = false;

        private CountDownLatch countDownLatch;

        public CountDownLatch getCountDownLatch()
        {
            return countDownLatch;
        }

        public void setCountDownLatch(CountDownLatch countDownLatch)
        {
            this.countDownLatch = countDownLatch;
        }

        public boolean isEnd()
        {
            return end;
        }

        public void setEnd(boolean end)
        {
            this.end = end;
        }
    }

    static class MyRunnable implements Runnable
    {

        private char c;

        private MyLock lock;

        public MyRunnable(char c, MyLock lock)
        {
            this.c = c;
            this.lock = lock;
        }

        @Override
        public void run()
        {
            synchronized (lock)
            {
                while (!lock.isEnd())
                {
                    System.out.print(c);
                    lock.getCountDownLatch().countDown();
                    try
                    {
                        lock.wait();
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }

        public char getC()
        {
            return c;
        }

        public void setC(char c)
        {
            this.c = c;
        }

    }
}

2.两个线程交替打印一段字符串

public class PrintWithTwoThread
{
    static int i = 0;

    public static void main(String[] args)
    {
        String str = "I'am hahaha";
        new Thread(() -> {
            synchronized (str)
            {
                while (i < str.length())
                {
                    System.out.println(Thread.currentThread().getName() + ":" + str.charAt(i));
                    i++;
                    try
                    {
                        str.notify();
                        str.wait();
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
                str.notify();
            }
        }, "1").start();

        new Thread(() -> {
            synchronized (str)
            {
                while (i < str.length())
                {
                    System.out.println(Thread.currentThread().getName() + ":" + str.charAt(i));
                    i++;
                    try
                    {
                        str.notify();
                        str.wait();
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
                str.notify();
            }
        }, "2").start();
    }

}