当前位置：首页 » 编程语言 » java多线程笔试题

java多线程笔试题

发布时间: 2021-03-17 03:49:45

❶ java 线程面试题

我不知道你是不是这个意思，thread1，thread2两个线程每次让j增加1，thread3，thread4两个线程每次让j减少1，四个线程每个都调用250次相关加减一操作。最终j的结果都是100.
下面程序，总计会打印出1000个数，不管怎么样最后一个数永远是100，即j的终值永远是100，为了看中间结果运行过程我加了sleep，但无关紧要。你看看符合你要求不？
就像楼上说的，启动1000条线程不是很明白，不一致的继续讨论
package com.kalort;

public class ThreadTest
{
public static void main(String[] args)
{
Operator operator = new Operator();
Thread thread1 = new IncreaseThread(operator);
Thread thread2 = new IncreaseThread(operator);
Thread thread3 = new DecreaseThread(operator);
Thread thread4 = new DecreaseThread(operator);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
}
}

class IncreaseThread extends Thread
{
private Operator operator;

public IncreaseThread(Operator operator)
{
this.operator = operator;
}

public void run()
{
for (int i = 0; i < 250; i++)
{
try
{
Thread.sleep((long)(Math.random() * 100));
}
catch (InterruptedException e)
{
e.printStackTrace();
}
operator.increase();
}
}
}

class DecreaseThread extends Thread
{
private Operator operator;

public DecreaseThread(Operator operator)
{
this.operator = operator;
}

public void run()
{
for (int i = 0; i < 250; i++)
{
try
{
Thread.sleep((long)(Math.random() * 100));
}
catch (InterruptedException e)
{
e.printStackTrace();
}
operator.decrease();
}
}
}

class Operator
{
private int j = 100;

public synchronized void increase()
{
while (100 != j)
{
try
{
wait(); // 如果另外线程还没减一就等待
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
j++;
System.out.println(j);
notify(); // 通知另外线程已经加一了。
}

public synchronized void decrease()
{
while (100 == j)
{
try
{
wait();
}
catch (InterruptedException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
j--;
System.out.println(j);
notify();
}
}

❷ java线程安全问题，笔试题帮忙给个思路。

1、两个线程，一个线程执行开门操作，一个线程执行关门操作，并都进行同步处理（synchronized)
2、假如在开门期间，按下按钮，刚开门线程wait，并notify关门线程开始run, 同理在关门期间，如果
按下按钮，则关门线程wait, 并notify开门线程执行
3、有一个注意的地方，每当在开门或关门期间按下按钮的时候，都要记录开门或关门最后一刻的状态值，以便在下次执行时，开门的从上一次关门最后一刻的状态开始执行，而关门的则上一个开门的最后一刻状态开始执行。个人见解。。。

❸ java有关线程的面试题

http://..com/question/346850241.html

❹ java多线程runnable和thread的区别面试题

runnable和thread的区别（多线程必须用Runable）
Java中有两种实现多线程的方式以及两种方式之间的区别
看到一个面试题.问两种实现多线程的方法.没事去网上找了找答案.
网上流传很广的是一个网上售票系统讲解.转发过来.已经不知道原文到底是出自哪里了.

Java中有两种实现多线程的方式。一是直接继承Thread类，二是实现Runnable接口。那么这两种实现多线程的方式在应用上有什么区别呢？
为了回答这个问题，我们可以通过编写一段代码来进行分析。我们用代码来模拟铁路售票系统，实现通过四个售票点发售某日某次列车的100张车票，一个售票点用一个线程表示。
首先这样编写这个程序：

Java代码
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() +
"is saling ticket" + ticket--);
}else{
break;
}
}
}
}
源码打印？
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() +
"is saling ticket" + ticket--);
}else{
break;
}
}
}
}

main测试类:

Java代码
public class ThreadDome1{
public static void main(String[] args){
ThreadTest t = new ThreadTest();
t.start();
t.start();
t.start();
t.start();
}
}
源码打印？
public class ThreadDome1{
public static void main(String[] args){
ThreadTest t = new ThreadTest();
t.start();
t.start();
t.start();
t.start();
}
}

上面的代码中，我们用ThreadTest类模拟售票处的售票过程，run方法中的每一次循环都将总票数减1，模拟卖出一张车票，同时该车票号打印出来，直接剩余的票数到零为止。在ThreadDemo1类的main方法中，我们创建了一个线程对象，并重复启动四次，希望通过这种方式产生四个线程。从运行的结果来看我们发现其实只有一个线程在运行，这个结果告诉我们：一个线程对象只能启动一个线程，无论你调用多少遍start()方法，结果只有一个线程。

我们接着修改ThreadDemo1，在main方法中创建四个Thread对象：

Java代码
public class ThreadDemo1{
public static void main(String[] args){
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
}
}
源码打印？
public class ThreadDemo1{
public static void main(String[] args){
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
}
}

Java代码
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() +
" is saling ticket" + ticket--);
}else{
break;
}
}
}
}
源码打印？
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() +
" is saling ticket" + ticket--);
}else{
break;
}
}
}
}

这下达到目的了吗？

从结果上看每个票号都被打印了四次，即四个线程各自卖各自的100张票，而不去卖共同的100张票。这种情况是怎么造成的呢？我们需要的是，多个线程去处理同一个资源，一个资源只能对应一个对象，在上面的程序中，我们创建了四个ThreadTest对象，就等于创建了四个资源，每个资源都有100张票，每个线程都在独自处理各自的资源。

经过这些实验和分析，可以总结出，要实现这个铁路售票程序，我们只能创建一个资源对象，但要创建多个线程去处理同一个资源对象，并且每个线程上所运行的是相同的程序代码。在回顾一下使用接口编写多线程的过程。

Java代码
public class ThreadDemo1{
public static void main(String[] args){
ThreadTest t = new ThreadTest();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}
源码打印？
public class ThreadDemo1{
public static void main(String[] args){
ThreadTest t = new ThreadTest();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}

Java代码
class ThreadTest implements Runnable{
private int tickets = 100;
public void run(){
while(true){
if(tickets > 0){
System.out.println(Thread.currentThread().getName() +
" is saling ticket " + tickets--);
}
}
}
}
源码打印？
class ThreadTest implements Runnable{
private int tickets = 100;
public void run(){
while(true){
if(tickets > 0){
System.out.println(Thread.currentThread().getName() +
" is saling ticket " + tickets--);
}
}
}
}

上面的程序中，创建了四个线程，每个线程调用的是同一个ThreadTest对象中的run()方法，访问的是同一个对象中的变量（tickets）的实例，这个程序满足了我们的需求。在Windows上可以启动多个记事本程序一样，也就是多个进程使用同一个记事本程序代码。

可见，实现Runnable接口相对于继承Thread类来说，有如下显著的好处：

(1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。

(2)可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。

(3)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象是，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。

❺ 某公司面试题java11使用并发多线程加速下载文件，如何写

先建一个用于下载文件的多线程类，通常要指明下载文件的位置(URL)和文件名以及保存到本地的路径
public class FileDownloader implements Runnable
{
private static File file;//要下载的文件
private static String url;//文件所在URL
private static File storagePath;//保存路径
public static void initialize(File file, String url, File storagePath)//初始化静态字段，初始化的代码不用我写吧
}
然后，指明同步块，目的是让各个线程共享一个文件资源，那样它们可以知道同一个文件的下载状况(即获取其他线程下载文件到哪个位置，以防重复下载)
public synchronized void fileDownload()//此方法用于下载文件，一般的Java程序员都会写，实在不会我可以帮你补上
或者
public void fileDownload(){
synchronized(file){
synchronized(url){
synchronized(storagePath){
}}}}//给每个字段加上同步块
run()方法的实现就以自己的喜好去写吧，只要里面调用了fileDownload()方法就行。
public void run(){
…
fileDownload();//下载文件
…
}
然后，在主类的main方法中创建一个多线程数组:
Runnable[] fds=new FileDownloader[线程数量];//fds为file_downloaders缩写
Thread[] threads=new Thread[线程数量];
最后使用循环把所有的线程逐一启动。
for(int i=0;i<线程数量;i++){
threads[i]=new Thread(fds[i]);
threads[i].start();
}

❻ 今天的笔试题，java中启动线程3种方法不是只有star（）吗

实现Runnable接口：
1）适合多个相同的程序代码的线程去处理同一个资源
2）可以避免java中的单继承的限制
3）增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。
继承Thread类：
1）可以将线程类抽象出来，当需要使用抽象工厂模式设计时。
2）多线程同步
在函数体使用（也就是star）
1）无需继承thread或者实现Runnable，缩小作用域。

❼ java笔试题：从线程和安全说一下sleep()和wait（）的区别

这两者的施加者是有本质区别的.
sleep()是让某个线程暂停运行一段时间,其控制范围是专由当前线程决属定,也就是说,在线程里面决定.好比如说,我要做的事情是 "点火->烧水->煮面",而当我点完火之后我不立即烧水,我要休息一段时间再烧.对于运行的主动权是由我的流程来控制.

而wait(),首先,这是由某个确定的对象来调用的,将这个对象理解成一个传话的人,当这个人在某个线程里面说"暂停!",也是thisOBJ.wait(),这里的暂停是阻塞,还是"点火->烧水->煮饭",thisOBJ就好比一个监督我的人站在我旁边,本来该线程应该执行1后执行2,再执行3,而在2处被那个对象喊暂停,那么我就会一直等在这里而不执行3,但正个流程并没有结束,我一直想去煮饭,但还没被允许,直到那个对象在某个地方说"通知暂停的线程启动!",也就是thisOBJ.notify()的时候,那么我就可以煮饭了,这个被暂停的线程就会从暂停处继续执行.

其实两者都可以让线程暂停一段时间,但是本质的区别是一个线程的运行状态控制,一个是线程之间的通讯的问题

❽ 面试问关于JAVA多线程,从哪些方面回答呢

应用场景
即作用是什么，哪些场景下需要，能解决哪类问题，通常情况下面试官更关心这个。
实现方式
除了什么时候用，你还得告诉他怎么用。什么Thread、Runnable、线程池之类的丢上去，这些比较基础。
线程同步
这个问题其实比较复杂。线程同步的概念最易于理解的案例就是在生产者消费者模式中的应用，你可以跟他讲讲这个。当然，这个涉及到对象锁基本就够了。
然后你再说说线程同步的几个方式，synchronized（对象、方法）、Lock、wait/notify之类的，说说它们的区别和应用场景。
最后提一提JDK中那些容器的线程同步问题，这样基本的使用算是不会有大问题了。

上面的东西你都能讲清楚，你多线程上的内容也就回个7788了，这块儿的面试基本没问题了

❾ java面试题 java多线程中有哪些锁

jvm自带一个锁机制，着一般需要知道，
synchronized锁，扫描全部线程，耗费内存较多，
lock锁

❿ 朋友们，今天去面试一家游戏公司的Java开发，有两道题：一道是多线程的实际应用中的题目，一道是SQL的

去了几天就被淘汰下来，你觉得值吗？直接问答案，还不如自己在网上搜索。

阅读全文

java多线程笔试题

与java多线程笔试题相关的阅读推荐