文档章节

Java多线程面试题

秋风醉了
 秋风醉了
发布于 04/18 17:54
字数 520
阅读 26
收藏 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=========

© 著作权归作者所有

共有 人打赏支持
秋风醉了
粉丝 236
博文 578
码字总数 419908
作品 0
朝阳
程序员
Java面试:投行的15个多线程和并发面试题

本文由ImportNew -一杯哈希不加盐 翻译自dzone。欢迎加入翻译小组。转载请见文末要求。 多线程和并发问题已成为各种 Java 面试中必不可少的一部分。如果你准备参加投行的 Java 开发岗位面试,...

ImportNew
08/23
0
0
金九银十,史上最强 Java 面试题整理。

以下会重新整理所有 Java 系列面试题答案、及各大互联网公司的面试经验,会从以下几个方面汇总,本文会长期更新。 Java 面试篇 史上最全 Java 面试题,带全部答案 史上最全 69 道 Spring 面试...

Java技术栈
09/13
0
0
【转】15个顶级Java多线程面试题及回答

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

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

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

LCZ777
2014/05/27
0
0
Android--面试中遇到的问题总结(三)

《Android 开发工程师面试指南 LearningNotes 》,作者是陶程,由梁观全贡献部分。大家可以去知乎关注这两位用心的少年。这份指南包含了大部分Android开发的基础、进阶知识,不仅可以帮助准备...

sealin
2017/02/22
0
0

没有更多内容

加载失败,请刷新页面

加载更多

Python基础案例教程

一、超市买薯片 # 用户输入薯片的单价danjia = float(input("薯片的单价"))# 用户输入购买袋数daishu = int(input("购买的袋数"))# 计算总价zongjia = danjia * daishu# 输出结果...

linuxprobe16
49分钟前
0
0
采用CXF框架发布webservice

package cn.it.ws.cxf.a;import javax.jws.WebParam;import javax.jws.WebResult;import javax.jws.WebService;@WebService(serviceName="languageManager")public interface ......

江戸川
51分钟前
0
0
HashMap工作原理及实现

HashMap工作原理及实现 1. 概述 什么时候会使用HashMap?他有什么特点? 知道HashMap的工作原理吗? 知道get和put的原理吗? 知道hash的实现吗?为什么要这样实现? 如果HashMap的大小超过了...

傅小水water
59分钟前
1
0
swagger如何屏蔽某些接口,不对外公开--使用@ApiIgnore

@ApiIgnore@RestController@RequestMapping(value = "/i18nTest")public class I18nTestController {// @Resource// private LocaleMessageSourceService localeMessageSourceSe......

karma123
今天
1
0
大数据技术学习,大数据处理为何选择Spark,而不是Hadoop

大数据处理为何选择Spark,而不是Hadoop。 一.基础知识 1.Spark Spark是一个用来实现快速而通用的集群计算的平台。 在速度方面,Spark扩展了广泛使用的MapReduce计算模型,而且高效地支持更多...

董黎明
今天
0
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部