Java多线程题目及答案
Java多线程习题

9、下列说法中错误的一项是( )。
A、Applet必须全部重写其生命周期方法
B、Applet不必全部重写其生命周期方法
C、Applet中使用了线程,则需要重写相应的生命周期方法
D、stop()总是在destroy()之前被调用。
B、用于建立与某个数据源的连接可采用DriverManager类的getConnection方法
C、建立数据库连接时,必须要进行异常处理
D JDBC中查询语句的执行方法必须采用Statement类实现
12、运行下列程序,会产生什么结果()
public class X extends Thread implements Runable{ public void run(){
18•实现线程体的方式除了继承Thread类,还可以实现接口。
E)A、Cloneable B、Runnable C、Iterable D、Serializable二、填空题
1、 若在高优先级线程的run()方法中调用_____方法,则该线程将让出CPU使其他 —
的线程获得CPU的使用权。
2、 通过实现Runnable接口创建线程的过程是:将实现Runnable的一个亠作为
Java
知识点:
Java的多线程,实现多线程的两种方法,线程控制、调度方法
一、选择题
1、什么原因可导致线程停止执行。 ( )
A.线程调用了wait()方法;
B.线程调用了yield()方法;
C.线程调用了pause()方法;
D.线程调用了sleep()方法。
2、 哪个方法是实现Runnable接口所需的?
13、下面哪个方法可以在任何时候被任何线程调用? ()
java多线程练习题(打印版)

java多线程练习题(打印版)### Java多线程练习题#### 题目一:实现一个简单的线程编写一个Java程序,创建一个线程,该线程打印出从1到10的数字。
```javapublic class SimpleThread extends Thread {public void run() {for (int i = 1; i <= 10; i++) {System.out.println(i);}}public static void main(String[] args) {SimpleThread thread = new SimpleThread();thread.start();}}```#### 题目二:线程同步编写一个Java程序,创建两个线程,它们交替打印字符串"A"和"B",直到每个线程打印5次。
```javapublic class ThreadSync {private static final Object lock = new Object();public static void main(String[] args) {Thread threadA = new Thread(() -> {for (int i = 0; i < 5; i++) {synchronized (lock) {System.out.print("A");lock.notify();try {lock.wait();} catch (InterruptedException e) { e.printStackTrace();}}}});Thread threadB = new Thread(() -> {for (int i = 0; i < 5; i++) {synchronized (lock) {System.out.print("B");lock.notify();try {lock.wait();} catch (InterruptedException e) { e.printStackTrace();}}}});threadA.start();threadB.start();}}```#### 题目三:生产者-消费者问题编写一个Java程序,模拟生产者-消费者问题。
JAVA并发多线程的面试问题及答案

JAVA并发多线程的面试问题及答案多线程和并发问题是Java技术面试中面试官比较喜欢问的问题之一。
在这里,从面试的角度列出了大部分重要的问题,但是你仍然应该牢固的掌握Java多线程基础知识来对应日后碰到的问题。
下面就由为大家介绍一下JAVA并发多线程的面试问题及答案的文章,欢迎阅读。
JAVA并发多线程的面试问题及答案篇11)现在有T1、T2、T3三个线程,你怎样保证T2在T1执行完后执行,T3在T2执行完后执行?这个线程问题通常会在第一轮或电话面试阶段被问到后的是检测你对〃join”方法是否熟悉。
这个多线程问题比较简单,可以用join 方法实现。
2)在Java中Lock接口比synchronized块的优势是什么?你需要实现一个高效的缓存,它允许多个用户读,但只允许一个用户写,以此来保持它的完整性,你会怎样去实现它?lock接口在多线程和并发编程中最大的优势是它们为读和写分别提供了锁,它能满足你写像ConcurrentHashM叩这样的高性能数据结构和有条件的阻塞。
Java线程面试的问题越来越会根据面试者的回答来提问。
我强烈建议在你去参加多线程的面试之前认真读一下Locks,因为当前其大量用于构建电子交易终统的客户端缓存和交易连接空间。
3)在java中wait和sleep方法的不同通常会在电话面试中经常被问到的Java线程面试问题。
最大的不同是在等待时wait会释放锁,而sleep 一直持有锁。
Wait通常被用于线程间交互,sleep通常被用于暂停执行。
4)用Java实现阻塞队列。
这是一个相对艰难的多线程面试问题,它能达到很多的目的。
第一,它可以检测侯选者是否能实际的用Java线程写程序;第二,可以检测侯选者对并发场景的理解,并且你可以根据这个问很多问题。
如果他用wait ()和notify()方法来实现阻塞队列,你可以要求他用最新的Java 5中的并发类来再写一次。
JAVA并发多线程的面试问题及答案篇21)用Java写代码来解决生产者;;消费者问题。
多线程常见面试题及答案

多线程常见⾯试题及答案1、如何在Java中实现线程(4种)?1.继承Thread类,重写run⽅法(其实Thread类本⾝也实现了Runnable接⼝)2.实现Runnable接⼝,重写run⽅法3.实现Callable接⼝,重写call⽅法(有返回值)4.使⽤线程池(有返回值)2、在具体多线程编程实践中,如何选⽤Runnable还是Thread?Java中实现多线程有两种⽅法:继承Thread类、实现Runnable接⼝,在程序开发中只要是多线程,肯定永远以实现Runnable接⼝为主,因为实现Runnable接⼝相⽐继承Thread类有如下优势:1、可以避免由于Java的单继承特性⽽带来的局限;2、增强程序的健壮性,代码能够被多个线程共享,代码与数据是独⽴的;适合多个相同程序代码的线程区处理同⼀资源的情况。
3、Thread类中的start()和run()⽅法有什么区别?start()⽅法来启动线程,真正实现了多线程运⾏,这时⽆需等待run⽅法体代码执⾏完毕⽽直接继续执⾏下⾯的代码:通过调⽤Thread类的start()⽅法来启动⼀个线程,这时此线程是处于就绪状态,并没有运⾏。
然后通过此Thread类调⽤⽅法run()来完成其运⾏操作的,这⾥⽅法run()称为线程体,它包含了要执⾏的这个线程的内容,Run⽅法运⾏结束,此线程终⽌,⽽CPU再运⾏其它线程。
run()⽅法当作普通⽅法的⽅式调⽤,程序还是要顺序执⾏,还是要等待run⽅法体执⾏完毕后才可继续执⾏下⾯的代码:⽽如果直接⽤run⽅法,这只是调⽤⼀个⽅法⽽已,程序中依然只有主线程–这⼀个线程,其程序执⾏路径还是只有⼀条,这样就没有达到多线程的⽬的。
4、Java中Runnable和Callable有什么不同相同点:1. 两者都是接⼝;(废话)2. 两者都可⽤来编写多线程程序;3. 两者都需要调⽤Thread.start()启动线程;不同点:1. 两者最⼤的不同点是:实现Callable接⼝的任务线程能返回执⾏结果;⽽实现Runnable接⼝的任务线程不能返回结果;2. Callable接⼝的call()⽅法允许抛出异常;⽽Runnable接⼝的run()⽅法的异常只能在内部消化,不能继续上抛;注意点:Callable接⼝⽀持返回执⾏结果,此时需要调⽤FutureTask.get()⽅法实现,此⽅法会阻塞主线程直到获取‘将来’结果;当不调⽤此⽅法时,主线程不会阻塞!5、如何避免死锁?1. 加锁顺序按照顺序加锁是⼀种有效的死锁预防机制。
Java多线程习题

Java多线程习题知识点:Java的多线程,实现多线程的两种方法,线程控制、调度方法一、选择题1、什么原因可导致线程停止执行。
()A.线程调用了 wait()方法;B.线程调用了yield()方法;C.线程调用了 pause()方法;D.线程调用了 sleep() 方法。
2、哪个方法是实现Runnable接口所需的?A.wait() B.run() C.stop() D.update() E.resume() 3、以下代码的调试结果为?()public class Bground extends Thread{public static void main(String argv[]){Bground b = new Bground();b。
run();}public void start(){for (int i = 0; i <10; i++){System。
out.println("Value of i = " + i);}}}A.编译错误,没有定义线程的run方法;B.由于没有定义线程的run方法,而出现运行错误;C。
编译通过,运行输出 values 0 to 9D。
编译通过,运行无输出4、有关线程的叙述正确的有:()A.通过继承Thread类或实现Runnable接口,可以获得对类中方法的互斥锁定.B. 可以获得对任何对象的互斥锁定。
C。
线程通过调用对象的synchronized 方法可取得对象的互斥锁定。
D。
线程调度算法是平台独立的。
5、以下哪个是线程类的方法?A.yield()B. sleep(long msec)C。
go()D。
stop()6、以下哪个最准确描述synchronized关键字?A.允许两线程并行运行,而且互相通信;B. 保证在某时刻只有一个线程可访问方法或对象;C。
保证允许两个或更多处理同时开始和结束;D. 保证两个或更多线程同时开始和结束.7、于Java语言的内存回收机制,下列选项中最正确的一项是( )。
多线程题目及答案

35. 并行和并发有什么区别?•并行是指两个或者多个事件在同一时刻发生;而并发是指两个或多个事件在同一时间间隔发生。
••并行是在不同实体上的多个事件,并发是在同一实体上的多个事件。
••在一台处理器上“同时”处理多个任务,在多台处理器上同时处理多个任务。
如hadoop分布式集群。
•所以并发编程的目标是充分的利用处理器的每一个核,以达到最高的处理性能。
36. 线程和进程的区别?简而言之,进程是程序运行和资源分配的基本单位,一个程序至少有一个进程,一个进程至少有一个线程。
进程在执行过程中拥有独立的内存单元,而多个线程共享内存资源,减少切换次数,从而效率更高。
线程是进程的一个实体,是cpu调度和分派的基本单位,是比程序更小的能独立运行的基本单位。
同一进程中的多个线程之间可以并发执行。
37. 守护线程是什么?守护线程(即daemon thread),是个服务线程,准确地来说就是服务其他的线程。
38. 创建线程有哪几种方式?①. 继承Thread类创建线程类•定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。
因此把run()方法称为执行体。
••创建Thread子类的实例,即创建了线程对象。
••调用线程对象的start()方法来启动该线程。
•②. 通过Runnable接口创建线程类•定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
••创建Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。
••调用线程对象的start()方法来启动该线程。
•③. 通过Callable和Future创建线程•创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。
••创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。
最全多线程经典面试题和答案

最全多线程经典⾯试题和答案Java实现线程有哪⼏种⽅式?1、继承Thread类实现多线程2、实现Runnable接⼝⽅式实现多线程3、使⽤ExecutorService、Callable、Future实现有返回结果的多线程多线程同步有哪⼏种⽅法?Synchronized关键字,Lock锁实现,分布式锁等。
Runnable和Thread⽤哪个好?Java不⽀持类的多重继承,但允许你实现多个接⼝。
所以如果你要继承其他类,也为了减少类之间的耦合性,Runnable会更好。
Java中notify和notifyAll有什么区别?notify()⽅法不能唤醒某个具体的线程,所以只有⼀个线程在等待的时候它才有⽤武之地。
⽽notifyAll()唤醒所有线程并允许他们争夺锁确保了⾄少有⼀个线程能继续运⾏。
为什么wait/notify/notifyAll这些⽅法不在thread类⾥⾯?这是个设计相关的问题,它考察的是⾯试者对现有系统和⼀些普遍存在但看起来不合理的事物的看法。
回答这些问题的时候,你要说明为什么把这些⽅法放在Object类⾥是有意义的,还有不把它放在Thread类⾥的原因。
⼀个很明显的原因是JAVA提供的锁是对象级的⽽不是线程级的,每个对象都有锁,通过线程获得。
如果线程需要等待某些锁那么调⽤对象中的wait()⽅法就有意义了。
如果wait()⽅法定义在Thread类中,线程正在等待的是哪个锁就不明显了。
简单的说,由于wait,notify和notifyAll都是锁级别的操作,所以把他们定义在Object类中因为锁属于对象。
为什么wait和notify⽅法要在同步块中调⽤?主要是因为Java API强制要求这样做,如果你不这么做,你的代码会抛出IllegalMonitorStateException异常。
还有⼀个原因是为了避免wait 和notify之间产⽣竞态条件。
什么是死锁?如何避免死锁?死锁就是两个线程相互等待对⽅释放对象锁。
java 多线程 编程题

java 多线程编程题
好的,以下是一个简单的Java 多线程编程题目:
题目:实现一个线程安全的计数器,当多个线程同时对计数器进行加1 操作时,计数器能够正确地累加计数。
要求:
1.计数器的初始值为0。
2.当多个线程同时对计数器进行加1 操作时,计数器能够正确地累加计数,保证计数
值的正确性。
3.使用synchronized 关键字保证计数器的线程安全性。
示例代码:
java
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
在这个示例代码中,我们定义了一个名为Counter 的类,它包含一个名为count 的整型变量和一个名为increment 的方法。
increment 方法用于将count 变量的值加1,并使用synchronized 关键字保证其线程安全性。
我们还定义了一个名为getCount 的方法,它也使用了synchronized 关键字来保证线程安全性,用于返回当前的计数值。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
任务8 多线程编程一、实验目的1. 掌握线程的概念、线程的生命周期。
2. 掌握采用继承Thread 类创建子线程。
3. 掌握使用Runnable 接口使类线程化。
二、实验要求1.掌握线程的概念、线程的生命周期。
2.掌握使用Runnable 接口使类线程化。
三、实验内容一、输入以下源代码,多次运行程序,分析输出结果1. 继承Thread 类创建子线程public class MultiThreadExample{public static void main(String []args){new ThreadDemo("A").start();//启动线程Anew ThreadDemo("B").start();//启动线程B}}class ThreadDemo extends Thread{public ThreadDemo(String n){super(n); //线程名称}public void run(){for(int i=0;i<5;i++){try{// 睡眠一段随机时间Thread.sleep((long)(Math.random() * 1000));}catch(InterruptedException e){e.printStackTrace();}System.out.print(getName()); //打印线程名称}}}2. 使用Runnable 接口使类线程化class MyThread1 implements Runnable { // 实现Runnable接口创建线程类MyThread public void run() { // 实现Runnable接口的run()方法for (int i = 0; i < 9; i++) {System.out.println(Thread.currentThread().getName()+i + " ");}}}public class ThreadExample2 {public static void main(String args[]) {MyThread1 mt = new MyThread1(); // 创建线程类MyThread的实例tThread t = new Thread(mt); // 创建Thread类的实例tt.start(); // 启动线程for (int i = 0; i < 9; i++) {System.out.println(Thread.currentThread().getName()+i + " ");}}}3 多次运行以下程序public class Tst11 implements Runnable {private int x;private int y;public static void main(String[] args) {Tst11 t = new Tst11();new Thread(t).start();new Thread(t).start();}public void run() {for (int i=1;i<20;i++) {try {Thread.sleep(200);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}x++;y++;System.out.println("x=" + x + ",y=" + y);}}}判断以上代码的运行结果是?A 编译不通过B 输出行类似x=1,y=1 ,总是重复一次。
C 输出行类似x=1,y=1 ,递增,每行不重复。
D 输出行类似x=2,y=3 ,x和y的值不一定相等分析结果并给出原因二、编写线程程序1 要求:设计一个线程操作类,要求产生3个线程对象,并可以分别设置三个线程的休眠时间,如下所示:1)线程A,休眠10秒2)线程B,休眠20秒3)线程C,休眠30秒package 线程;class MyThread extends Thread{private int sleeptime;public MyThread(String s) {super(s);}public void setSleepTime(int sleeptime) {this.sleeptime= sleeptime;}public void run() {try {System.out.println(Thread.currentThread().getName()+"进入休眠,休眠时间为:"+sleeptime/1000+"秒");Thread.sleep(sleeptimess);System.out.println(Thread.currentThread().getName()+"休眠结束。
");} catch (InterruptedException e) {// TODO自动生成的 catch 块e.printStackTrace();}}}public class Test1 {public static void main(String[] args) {MyThread A = new MyThread("线程A");A.setSleepTime(10000);MyThread B = new MyThread("线程B");B.setSleepTime(20000);MyThread C = new MyThread("线程C");C.setSleepTime(30000);A.start();B.start();C.start();}}2 编写线程程序,要求:一个线程进行阶乘计算(1!+2!+3!+...100!),每次计算时间随机间隔1-10毫秒;另个线程每隔10毫秒时间读取并线程上个线程的运算结果和计算阶乘,比如1!+2!=3package 线程;class MyThreadTest1 implements Runnable{double sum = 0;int i;public void run() {double a = 1;for (int i = 1; i <= 100; i++) {a *= i;sum += a;int b = (int)(Math.random()*10);try {Thread.sleep(b);} catch (InterruptedException e) {// TODO自动生成的 catch 块e.printStackTrace();}}System.out.println(sum);}}public class Test2 {public static void main(String[] args) {MyThreadTest1 my = new MyThreadTest1();new Thread(my).start();while(my.i<=100) {try {Thread.sleep(10);} catch (InterruptedException e) {// TODO自动生成的 catch 块e.printStackTrace();}System.out.println(my.sum);}}}3 编写2个线程,第一个线程,打印字母A-Z,第二个线程打印数字0-9,要求先打印完数字才能打印字母。
package 线程;class Thread1 extends Thread{public void run() {for(int i = 0;i < 10;i++) {System.out.println(i);}}}class Thread2 extends Thread{public void run() {char zi = 'A';for(int i = 0;i < 26;i++) {System.out.println(zi);zi++;}}}public class Test3 {public static void main(String[] args) {Thread1 t1 = new Thread1();Thread2 t2 = new Thread2();t1.start();try {t1.join();} catch (InterruptedException e) {// TODO自动生成的 catch 块e.printStackTrace();}t2.start();}}4有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池用一个数组int[] arr ={10,5,20,50,100,200,500,800,2,80,300};创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”,“抽奖箱2”,随机从arr数组中获取奖项元素并打印在控制台上,格式如下:抽奖箱1 又产生了一个 10 元大奖抽奖箱2 又产生了一个 100 元大奖 //.....package 线程;public class Test4 {public static void main(String[] args) {Jang j = new Jang();Thread t3 = new Thread(j,"抽奖箱1");Thread t4 = new Thread(j,"抽奖箱2");t3.start();t4.start();}}class Jang implements Runnable{int[] arr = {10,5,20,50,100,200,500,800,2,80,300};int count = arr.length;boolean [] flag = new boolean[arr.length];public void run() {while(true) {synchronized (this) {if(count>0) {//随机获取数组下标int index = (int)(Math.random()*arr.length);//获取得到的数字int get = arr[index];//代表这张奖票已经抽过if(flag[index]!= true) {flag[index] = true;System.out.println(Thread.currentThread().getName()+"又产生了一个"+get+"元大奖!");count--;}}}}}}5 模拟多个人通过一个山洞。