JAVA并发编程练习题

忘是亡心i 2022-05-23 11:05 141阅读 0赞

## 前言 ##

学了几天的多线程基础部分，书上的东西一看就懂，但是真的实践还是值得推敲的

## 题目 ##

1、写一个程序，线程C在线程B后执行，线程B在线程A之后进行

package thread;
    
    public class Test { 
    
        public static void main(String[] args) {
            Thread threadA = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    System.out.println("This is A");
                }
            });
    
            Thread threadB = new Thread(() -> {
                try {
                    threadA.join();
                } catch (Exception e) {
                    // TODO: handle exception
                }
                System.out.println("This is B");
            });
    
            Thread threadC = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    try {
                        threadB.join();
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                    System.out.println("This is C");
                }
            });
            threadA.start();
            threadB.start();
            threadC.start();
        }
    }

或者这样

package thread;
    
    public class Test2 { 
        public static void main(String[] args) {
            Thread aThread = new Thread(() -> {
                System.out.println("This is A");
            });
            Thread bThread = new Thread(() -> {
                System.out.println("This is B");
            });
            Thread cThread = new Thread(() -> {
                System.out.println("This is C");
            });
            try {
                aThread.start();
                aThread.join();
                bThread.start();
                bThread.join();
                cThread.start();
                cThread.join();
            } catch (Exception e) {
                // TODO: handle exception
            }
    
        }
    }

2、编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推。

## 第一次代码 ##

package thread;
    
    public class Test4 { 
        public static void main(String[] args) {
            Thread threadA = new Thread(() -> {
                System.out.println("This is A");
            });
    
            Thread threadB = new Thread(() -> {
                try {
                    threadA.join();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("This is B");
            });
    
            Thread threadC = new Thread(() -> {
                try {
                    threadB.join();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("This is C");
            });
    
            for (int i=0;i<10;i++) {
                threadA.start();
                threadB.start();
                threadC.start();
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
    ---output----
    This is A
    This is B
    This is C
    Exception in thread "main" java.lang.IllegalThreadStateException
        at java.base/java.lang.Thread.start(Thread.java:804)
        at thread.Test4.main(Test4.java:30)

分析：  
一开始我以为是执行地太快了，在main里面sleep了一会，结果发现还是崩了，最后google才发现，原来同样的线程不能循环执行，这和线程的生命周期有关系。销毁了之后就不能再进行了。

## 第二次代码 ##

package thread;
    
    public class Test3 { 
        public static void main(String[] args) {
    
            for (int i = 0; i < 10; i++) {
                Thread threadA = new Thread(() -> {
                    System.out.println(Thread.currentThread().getName());
                }, "A");
    
                Thread threadB = new Thread(() -> {
                    try {
                        threadA.join();
                        System.out.println(Thread.currentThread().getName());
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                }, "B");
    
                Thread threadC = new Thread(() -> {
                    try {
                        threadB.join();
                        System.out.println(Thread.currentThread().getName());
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                }, "C");
    
    
    
                threadC.start();
                threadB.start();
                threadA.start();
                try {
                    Thread.sleep(300);
                } catch (Exception e) {
                    // TODO: handle exception
                }
            }
        }
    }

分析：  
这里的sleep比较重要，因为每次都new了一个线程，主线程执行地太快，会导致新的线程先于旧线程的顺序执行。类似于插队了。但是我觉得这里new了多个线程不太好，为什么不用3个线程直接完成呢？好像不符合题目的开启3个线程这个条件

## 第三次代码 ##

package thread;
    
    public class Test {
        public static class Worker {
            Object lock = new Object();
            int flag = 1;
    
            public void PrintA() {
                synchronized (lock) {
                    while (flag != 1) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            // TODO: handle exception
                        }
                    }
                    flag = 2;
                    lock.notifyAll();
                    System.out.println(Thread.currentThread().getName());
                }
            }
    
            public void PrintB() {
                synchronized (lock) {
                    while (flag != 2) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            // TODO: handle exception
                        }
                    }
                    flag = 3;
                    lock.notifyAll();
                    System.out.println(Thread.currentThread().getName());
                }
            }
    
            public void PrintC() {
                synchronized (lock) {
                    while (flag != 3) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            // TODO: handle exception
                        }
                    }
                    flag = 1;
                    lock.notifyAll();
                    System.out.println(Thread.currentThread().getName());
                }
            }
    
        }
    
        public static void main(String[] args) {
            Worker worker = new Worker();
    
            Thread threadA = new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    worker.PrintA();
                }
            }, "A");
            Thread threadB = new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    worker.PrintB();
                }
            }, "B");
            Thread threadC = new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    worker.PrintC();
                }
            }, "C");
    
            threadA.start();
            threadB.start();
            threadC.start();
        }
    }