Java多线程面试题

2019独角兽企业重金招聘Python工程师标准>>>

Java多线程面试题

1.多线程顺序执行 使用join协调线程执行顺序

/**
 * 顺序打印 A B C 使用 join 来协调执行顺序
 */
public class ThreadTest {

    public static void main(String[] args) throws InterruptedException {
        Thread A = new Thread(new MyThread("A"));
        Thread B = new Thread(new MyThread("B"));
        Thread C = new Thread(new MyThread("C"));

        A.start();
        A.join();
        B.start();
        B.join();
        C.start();
        C.join();
    }
}

class MyThread implements Runnable {

    private String name;

    public MyThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(name);
    }
}

2.多线程顺序执行 使用 wait & notifyAll

public class ThreadTest2 {

    static volatile int state = 0;

    static final Object lock = new Object();

    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    while (true) {
                        if (state != 2) {
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        if (state == 2) {
                            System.out.println("C");
                            state++;
                            lock.notifyAll();
                            break;
                        }
                    }

                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    while (true) {
                        if (state != 1) {
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        if (state == 1) {
                            System.out.println("B");
                            state++;
                            lock.notifyAll();
                            break;
                        }
                    }

                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                if (state == 0) {
                    synchronized (lock) {
                        System.out.println("A");
                        state++;
                        lock.notifyAll();
                    }
                }
            }
        }).start();

    }
}

3.两个线程交替打印 1-99

/**
 * 两个线程 交替打印字符串
 */
public class ThreadTest4 {

    static final Object lock = new Object();
    static int num1 = 0;
    static int num2 = 1;
    static int end = 100;
    volatile static int state = 0;

    public static void main(String[] args) {

        Thread a = new Thread() {
            public void run() {
                synchronized (lock) {
                    while (true) {
                        if (state == 1) {
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        state = 1;
                        if (num1 >= end) {
                            break;
                        }
                        System.out.println(num1);
                        num1 += 2;
                        lock.notify();
                    }
                }

            }
        };


        Thread b = new Thread() {
            public void run() {
                synchronized (lock) {
                    while (true) {
                        if (state == 0) {
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        state = 0;
                        if (num2 >= end) {
                            break;
                        }
                        System.out.println(num2);
                        num2 += 2;
                        lock.notify();
                    }
                }

            }
        };
        b.start();
        a.start();
    }
}

4.多线程求和 1+2+3+...+99

package com.rocketmq.thread;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class ThreadSum extends Thread {

    static int totalCount;

    private int start;
    private int end;
    private CyclicBarrier barrier;

    public ThreadSum(int start, int end, CyclicBarrier barrier) {
        this.start = start;
        this.end = end;
        this.barrier = barrier;
    }

    @Override
    public void run() {
        int count = 0;
        for (int i = start; i < end + 1; i++) {
            count += i;
        }

        //需要获取锁对 totalCount 累加
        synchronized (ThreadSum.class) {
            totalCount += count;
        }

        try {
            // 进入到同步屏障阻塞等待所有线程进入同步屏障然后返回
            barrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        int max = 20000; //对从1到20,000求和
        int nThreads = 10;
        CyclicBarrier barrier = new CyclicBarrier(nThreads, new Runnable() {
            @Override
            public void run() {
                System.out.println(ThreadSum.totalCount);
            }
        });

        for (int i = 0; i < nThreads; i++) {
            int fromInt = max * i / nThreads + 1; //边界条件
            int toInt = max * (i + 1) / nThreads; //边界条件
            new ThreadSum(fromInt, toInt, barrier).start();
        }

    }
}

=========END=========

转载于:https://my.oschina.net/xinxingegeya/blog/1797425