java线程练习题及答案

线程与线程类

1 线程的概念

线程的概念来源于计算机的操作系统的进程的概念。进程是一个程序关于某个数据集的一次运行。也就是说，进程是运行中的程序，是程序的一次运行活动。

线程和进程的相似之处在于，线程和运行的程序都是单个顺序控制流。有些教材将线程称为轻量级进程(light weight process)。线程被看作是轻量级进程是因为它运行在一个程序的上下文内，并利用分配给程序的资源和环境。

作为单个顺序控制流，线程必须在运行的程序中得到自己运行的资源，如必须有自己的执行栈和程序计数器。线程内运行的代码只能在该上下文内。因此还有些教程将执行上下文(execution context)作为线程的同义词。

所有的程序员都熟悉顺序程序的编写，如我们编写的名称排序和求素数的程序就是顺序程序。顺序程序都有开始、执行序列和结束，在程序执行的任何时刻，只有一个执行点。线程（thread ）则是进程中的一个单个的顺序控制流。单线程的概念很简单，如图1所示。 多线程（multi-thread ）是指在单个的程序内可以同时运行多个不同的线程完成不同的任务，图2说明了一个程序中同时有两个线程运行。

图1 单线程程序示意图 图2 多线程程序示意图

有些程序中需要多个控制流并行执行。例如，

for(int i = 0; i < 100; i++)

System.out.println("Runner A = " + i);

for(int j = 0; j < 100; j++ )

System.out.println("Runner B = "+j);

上面的代码段中，在只支持单线程的语言中，前一个循环不执行完不可能执行第二个循环。要使两个循环同时执行，需要编写多线程的程序。

很多应用程序是用多线程实现的，如Hot Java Web 浏览器就是多线程应用的例子。在Hot Java 浏览器中，你可以一边滚动屏幕，一边下载Applet 或图像，可以同时播放动画和声音等。

2 Thread 类和Runnable 接口

多线程是一个程序中可以有多段代码同时运行，那么这些代码写在哪里，如何创建线程对象呢?

首先，我们来看Java 语言实现多线程编程的类和接口。在https://www.sodocs.net/doc/148392773.html,ng 包中定义了Runnable 接口和Thread 类。

Runnable接口中只定义了一个方法，它的格式为：

?public abstract void run()

这个方法要由实现了Runnable接口的类实现。Runnable对象称为可运行对象，一个线程的运行就是执行该对象的run()方法。

Thread类实现了Runnable接口，因此Thread对象也是可运行对象。同时Thread类也是线程类，该类的构造方法如下：

?public Thread()

?public Thread(Runnable target)

?public Thread(String name)

?public Thread(Runnable target, String name)

?public Thread(ThreadGroup group, Runnable target)

?public Thread(ThreadGroup group, String name)

?public Thread(ThreadGroup group, Runnable target, String name)

target为线程运行的目标对象，即线程调用start()方法启动后运行那个对象的run()方法，该对象的类型为Runnable，若没有指定目标对象，则以当前类对象为目标对象；name为线程名，group指定线程属于哪个线程组（有关线程组的概念请参考9.6节）。

Thread类的常用方法有：

?public static Thread currentThread() 返回当前正在执行的线程对象的引用。

?public void setName(String name) 设置线程名。

?public String getName() 返回线程名。

?public static void sleep(long millis) throws InterruptedException

?public static void sleep(long millis, int nanos) throws InterruptedException 使当前正在执行的线程暂时停止执行指定的毫秒时间。指定时间过后，线程继续执行。该方法抛出InterruptedException异常，必须捕获。

?public void run() 线程的线程体。

?public void start() 由JVM调用线程的run()方法，启动线程开始执行。

?public void setDaemon(boolean on) 设置线程为Daemon线程。

?public boolean isDaemon() 返回线程是否为Daemon线程。

?public static void yield() 使当前执行的线程暂停执行，允许其他线程执行。

?public ThreadGroup getThreadGroup() 返回该线程所属的线程组对象。

?public void interrupt() 中断当前线程。

?public boolean isAlive() 返回指定线程是否处于活动状态。

线程的创建

本节介绍如何创建和运行线程的两种方法。线程运行的代码就是实现了Runnable接口的类的run()方法或者是Thread类的子类的run()方法，因此构造线程体就有两种方法：?继承Thread类并覆盖它的run()方法；

?实现Runnable接口并实现它的run()方法。

继承Thread类创建线程

通过继承Thread类，并覆盖run()方法，这时就可以用该类的实例作为线程的目标对象。下面的程序定义了SimpleThread类，它继承了Thread类并覆盖了run()方法。

程序SimpleThread.java

public class SimpleThread extends Thread{

public SimpleThread(String str){

super(str);

}

public void run(){

for(int i=0; i<100; i++){

System.out.println(getName()+" = "+ i);

try{

sleep((int)(Math.random()*100));

}catch(InterruptedException e){}

}

System.out.println(getName()+ " DONE");

}

}

_____________________________________________________________________________▃

SimpleThread类继承了Thread类，并覆盖了run()方法，该方法就是线程体。

程序ThreadTest.java

public class ThreadTest{

public static void main(String args[]){

Thread t1 = new SimpleThread("Runner A");

Thread t2 = new SimpleThread("Runner B");

t1.start();

t2.start();

}

}

_____________________________________________________________________________▃

在ThreadTest类的main()方法中创建了两个SimpleThread类的线程对象并调用线程类的start()方法启动线程。构造线程时没有指定目标对象，所以线程启动后执行本类的run()方法。

注意，实际上ThreadTest程序中有三个线程同时运行。请试着将下段代码加到main()方法中，分析程序运行结果。

for(int i=0; i<100; i++){

System.out.println(Thread.currentThread().getName()+"="+ i);

try{

Thread.sleep((int)(Math.random()*500));

}catch(InterruptedException e){}

System.out.println(Thread.currentThread().getName()+ " DONE");

}

从上述代码执行结果可以看到，在应用程序的main()方法启动时，JVM就创建一个主线程，在主线程中可以创建其他线程。

再看下面的程序：

程序MainThreadDemo.java

public class MainThreadDemo{

public static void main(String args[]){

Thread t = Thread.currentThread();

t.setName("MyThread");

System.out.println(t);

System.out.println(t.getName());

System.out.println(t.getThreadGroup().getName());

}

}

_____________________________________________________________________________▃该程序输出结果为：

Thread[MyThread, 5, main]

MyThread

main

上述程序在main()方法中声明了一个Thread对象t，然后调用Thread类的静态方法currentThread()获得当前线程对象。然后重新设置该线程对象的名称，最后输出线程对象、线程组对象名和线程对象名。

实现Runnable接口创建线程

可以定义一个类实现Runnable接口，然后将该类对象作为线程的目标对象。实现Runnable接口就是实现run()方法。

下面程序通过实现Runnable接口构造线程体。

程序ThreadTest.java

class T1 implements Runnable{

public void run(){

for(int i=0;i<15;i++)

System.out.println("Runner A="+i);

}

}

class T2 implements Runnable{

public void run(){

for(int j=0;j<15;j++)

System.out.println("Runner B="+j);

}

}

public class ThreadTest{

public static void main(String args[]){

Thread t1=new Thread(new T1(),"Thread A");

Thread t2=new Thread(new T2(),"Thread B");

t1.start();

t2.start();

}

}

_____________________________________________________________________________▃

线程的状态与调度

1线程的生命周期

线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。线程的状态如图4所示：

图4 线程的五种状态

下面以前面的Java小程序为例说明线程的状态：

1. 新建状态(New Thread)

当Applet启动时调用Applet的start()方法，此时小应用程序就创建一个Thread对象clockThread。

public void start() {

if (clockThread == null) {

clockThread = new Thread(cp, "Clock");

clockThread.start();

}

}

当该语句执行后clockThread就处于新建状态。处于该状态的线程仅仅是空的线程对象，并没有为其分配系统资源。当线程处于该状态，你仅能启动线程，调用任何其他方法是无意义的且会引发IllegalThreadStateException异常(实际上，当调用线程的状态所不允许的任何方法时，运行时系统都会引发IllegalThreadStateException异常)。

注意cp作为线程构造方法的第一个参数，该参数必须是实现了Runnable接口的对象并提供线程运行的run()方法，第二个参数是线程名。

2. 就绪状态(Runnable)

一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，如clockThread.start(); 语句就是启动clockThread线程。start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。

处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。

3. 运行状态(Running)

当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法，这里run()方法中是一个循环，循环条件是true。

public void run() {

while (true) {

repaint();

try {

Thread.sleep(1000);

} catch (InterruptedException e){}

}

4. 阻塞状态(Blocked)

线程运行过程中，可能由于各种原因进入阻塞状态。所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间，进入运行状态。有关阻塞状态在后面详细讨论。

5. 死亡状态(Dead)

线程的正常结束，即run()方法返回，线程运行就结束了，此时线程就处于死亡状态。本例子中，线程运行结束的条件是clockThread为null，而在小应用程序的stop()方法中，将clockThread赋值为null。即当用户离开含有该小应用程序的页面时，浏览器调用stop()方法，将clockThread赋值为null，这样在run()的while循环时条件就为false，这样线程运行就结束了。如果再重新访问该页面，小应用程序的start()方法又会重新被调用，重新创建并启动

一个新的线程。

public void stop() {

clockThread = null;

}

程序不能像终止小应用程序那样通过调用一个方法来结束线程(小应用程序通过调用stop()方法结束小应用程序的运行)。线程必须通过run()方法的自然结束而结束。通常在run()方法中是一个循环，要么是循环结束，要么是循环的条件不满足，这两种情况都可以使线程正常结束，进入死亡状态。

例如，下面一段代码是一个循环：

public void run(){

int i = 0;

while(i<100){

i++;

System.out.println("i = " + i );

}

}

当该段代码循环结束后，线程就自然结束了。注意一个处于死亡状态的线程不能再调用该线程的任何方法。

2 线程的优先级和调度

Java的每个线程都有一个优先级，当有多个线程处于就绪状态时，线程调度程序根据线程的优先级调度线程运行。

可以用下面方法设置和返回线程的优先级。

?public final void setPriority(int newPriority) 设置线程的优先级。

?public final int getPriority() 返回线程的优先级。

newPriority为线程的优先级，其取值为1到10之间的整数，也可以使用Thread类定义的常量来设置线程的优先级，这些常量分别为：Thread.MIN_PRIORITY、Thread.NORM_PRIORITY、Thread.MAX_PRIORITY，它们分别对应于线程优先级的1、5和10，数值越大优先级越高。当创建Java线程时，如果没有指定它的优先级，则它从创建该线程那里继承优先级。

一般来说，只有在当前线程停止或由于某种原因被阻塞，较低优先级的线程才有机会运行。

前面说过多个线程可并发运行，然而实际上并不总是这样。由于很多计算机都是单CPU 的，所以一个时刻只能有一个线程运行，多个线程的并发运行只是幻觉。在单CPU机器上多个线程的执行是按照某种顺序执行的，这称为线程的调度(scheduling)。

大多数计算机仅有一个CPU，所以线程必须与其他线程共享CPU。多个线程在单个CPU 是按照某种顺序执行的。实际的调度策略随系统的不同而不同，通常线程调度可以采用两种策略调度处于就绪状态的线程。

(1) 抢占式调度策略

Java运行时系统的线程调度算法是抢占式的(preemptive)。Java运行时系统支持一种简单的固定优先级的调度算法。如果一个优先级比其他任何处于可运行状态的线程都高的线程进入就绪状态，那么运行时系统就会选择该线程运行。新的优先级较高的线程抢占(preempt)了其他线程。但是Java运行时系统并不抢占同优先级的线程。换句话说，Java运行时系统不是分时的(time-slice)。然而，基于Java Thread类的实现系统可能是支持分时的，因此编写代码时不要依赖分时。当系统中的处于就绪状态的线程都具有相同优先级时，线程调度程序采用一种简单的、非抢占式的轮转的调度顺序。

(2) 时间片轮转调度策略

有些系统的线程调度采用时间片轮转(round-robin)调度策略。这种调度策略是从所有处于就绪状态的线程中选择优先级最高的线程分配一定的CPU时间运行。该时间过后再选择其他线程运行。只有当线程运行结束、放弃(yield)CPU或由于某种原因进入阻塞状态，低优先级的线程才有机会执行。如果有两个优先级相同的线程都在等待CPU，则调度程序以轮转的方式选择运行的线程。

线程状态的改变

一个线程在其生命周期中可以从一种状态改变到另一种状态，线程状态的变迁如图5所示：

图5 线程状态的改变

1 控制线程的启动和结束

当一个新建的线程调用它的start()方法后即进入就绪状态，处于就绪状态的线程被线程调度程序选中就可以获得CPU时间，进入运行状态，该线程就开始运行run()方法。

控制线程的结束稍微复杂一点。如果线程的run()方法是一个确定次数的循环，则循环结束后，线程运行就结束了，线程对象即进入死亡状态。如果run()方法是一个不确定循环，早期的方法是调用线程对象的stop()方法，然而由于该方法可能导致线程死锁，因此从1.1版开始，不推荐使用该方法结束线程。一般是通过设置一个标志变量，在程序中改变标志变量的值实现结束线程。请看下面的例子：

程序ThreadStop.java

import java.util.*;

class Timer implements Runnable{

boolean flag=true;

public void run(){

while(flag){

System.out.print("\r\t"+new Date()+"...");

try{

Thread.sleep(1000);

}catch(InterruptedException e){}

}

System.out.println("\n"+Thread.currentThread().getName()+" Stop");

}

public void stopRun(){

flag = false;

}

}

public class ThreadStop{

public static void main(String args[]){

Timer timer = new Timer();

Thread thread = new Thread(timer);

thread.setName("Timer");

thread.start();

for(int i=0;i<100;i++){

System.out.print("\r"+i);

try{

Thread.sleep(100);

}catch(InterruptedException e){}

}

timer.stopRun();

}

}

_____________________________________________________________________________▃

该程序在Timer类中定义了一个布而变量flag，同时定义了一个stopRun()方法，在其中将该变量设置为false。在主程序中通过调用该方法，从而改变该变量的值，使得run()方法的while循环条件不满足，从而实现结束线程的运行。

说明在Thread类中除了stop()方法被标注为不推荐(deprecated) 使用外，suspend()方法和resume()方法也被标明不推荐使用，这两个方法原来用作线程的挂起和恢

复。

2 线程阻塞条件

处于运行状态的线程除了可以进入死亡状态外，还可能进入就绪状态和阻塞状态。下面分别讨论这两种情况：

(1) 运行状态到就绪状态

处于运行状态的线程如果调用了yield()方法，那么它将放弃CPU时间，使当前正在运行的线程进入就绪状态。这时有几种可能的情况：如果没有其他的线程处于就绪状态等待运行，该线程会立即继续运行；如果有等待的线程，此时线程回到就绪状态状态与其他线程竞争CPU时间，当有比该线程优先级高的线程时，高优先级的线程进入运行状态，当没有比该线程优先级高的线程时，但有同优先级的线程，则由线程调度程序来决定哪个线程进入运行状态，因此线程调用yield()方法只能将CPU时间让给具有同优先级的或高优先级的线程而不能让给低优先级的线程。

一般来说，在调用线程的yield()方法可以使耗时的线程暂停执行一段时间，使其他线程有执行的机会。

(2) 运行状态到阻塞状态

有多种原因可使当前运行的线程进入阻塞状态，进入阻塞状态的线程当相应的事件结束或条件满足时进入就绪状态。使线程进入阻塞状态可能有多种原因：

①线程调用了sleep()方法，线程进入睡眠状态，此时该线程停止执行一段时间。当时间到时该线程回到就绪状态，与其他线程竞争CPU时间。

Thread类中定义了一个interrupt()方法。一个处于睡眠中的线程若调用了interrupt()方法，该线程立即结束睡眠进入就绪状态。

②如果一个线程的运行需要进行I/O操作，比如从键盘接收数据，这时程序可能需要等待用户的输入，这时如果该线程一直占用CPU，其他线程就得不到运行。这种情况称为I/O阻塞。这时该线程就会离开运行状态而进入阻塞状态。Java语言的所有I/O方法都具有这种行为。

③有时要求当前线程的执行在另一个线程执行结束后再继续执行，这时可以调用join()方法实现，join()方法有下面三种格式：

?public void join() throws InterruptedException 使当前线程暂停执行，等待调用该方法的线程结束后再执行当前线程。

?public void join(long millis) throws InterruptedException 最多等待millis毫秒后，当前线程继续执行。

?public void join(long millis, int nanos) throws InterruptedException 可以指定多少毫秒、多少纳秒后继续执行当前线程。

上述方法使当前线程暂停执行，进入阻塞状态，当调用线程结束或指定的时间过后，当前线程线程进入就绪状态，例如执行下面代码：

t.join();

将使当前线程进入阻塞状态，当线程t执行结束后，当前线程才能继续执行。

④线程调用了wait()方法，等待某个条件变量，此时该线程进入阻塞状态。直到被通知(调用了notify()或notifyAll()方法)结束等待后，线程回到就绪状态。

⑤另外如果线程不能获得对象锁，也进入就绪状态。

后两种情况在下一节讨论。

线程的同步与共享

前面程序中的线程都是独立的、异步执行的线程。但在很多情况下，多个线程需要共享数据资源，这就涉及到线程的同步与资源共享的问题。

1 资源冲突

下面的例子说明，多个线程共享资源，如果不加以控制可能会产生冲突。

程序CounterTest.java

class Num{

private int x=0;

private int y=0;

void increase(){

x++;

y++;

}

void testEqual(){

System.out.println(x+","+y+":"+(x==y));

}

}

class Counter extends Thread{

private Num num;

Counter(Num num){

this.num=num;

}

public void run(){

while(true){

num.increase();

}

}

}

public class CounterTest{

public static void main(String[] args){

Num num = new Num();

Thread count1 = new Counter(num);

Thread count2 = new Counter(num);

count1.start();

count2.start();

for(int i=0;i<100;i++){

num.testEqual();

try{

Thread.sleep(100);

}catch(InterruptedException e){ }

}

}

}

_____________________________________________________________________________▃

上述程序在CounterTest类的main()方法中创建了两个线程类Counter的对象count1和count2，这两个对象共享一个Num类的对象num。两个线程对象开始运行后，都调用同一个对象num的increase()方法来增加num对象的x和y的值。在main()方法的for()循环中输出num对象的x和y的值。程序输出结果有些x、y的值相等，大部分x、y的值不相等。

出现上述情况的原因是：两个线程对象同时操作一个num对象的同一段代码，通常将这段代码段称为临界区(critical sections)。在线程执行时，可能一个线程执行了x++语句而尚未执行y++语句时，系统调度另一个线程对象执行x++和y++，这时在主线程中调用testEqual()方法输出x、y的值不相等。

这里可能出现x的值小于y的值的情况，为什么？

2 对象锁的实现

上述程序的运行结果说明了多个线程访问同一个对象出现了冲突，为了保证运行结果正确(x、y的值总相等)，可以使用Java语言的synchronized关键字，用该关键字修饰方法。用synchronized关键字修饰的方法称为同步方法，Java平台为每个具有synchronized代码段的对象关联一个对象锁(object lock)。这样任何线程在访问对象的同步方法时，首先必须获得对象锁，然后才能进入synchronized方法，这时其他线程就不能再同时访问该对象的同步方法了(包括其他的同步方法)。

通常有两种方法实现对象锁：

(1) 在方法的声明中使用synchronized关键字，表明该方法为同步方法。

对于上面的程序我们可以在定义Num类的increase()和testEqual()方法时，在它们前面加上synchronized关键字，如下所示：

synchronized void increase(){

x++;

y++;

}

synchronized void testEqual(){

System.out.println(x+","+y+":"+(x==y)+":"+(x

}

一个方法使用synchronized关键字修饰后，当一个线程调用该方法时，必须先获得对象锁，只有在获得对象锁以后才能进入synchronized方法。一个时刻对象锁只能被一个线程持有。如果对象锁正在被一个线程持有，其他线程就不能获得该对象锁，其他线程就必须等待持有该对象锁的线程释放锁。

如果类的方法使用了synchronized关键字修饰，则称该类对象是线程安全的，否则是线程不安全的。

如果只为increase()方法添加synchronized 关键字，结果还会出现x、y的值不相等的情况，请考虑为什么？

(2) 前面实现对象锁是在方法前加上synchronized 关键字，这对于我们自己定义的类很容易实现，但如果使用类库中的类或别人定义的类在调用一个没有使用synchronized关键字修饰的方法时，又要获得对象锁，可以使用下面的格式：

synchronized(object){

//方法调用

}

假如Num类的increase()方法没有使用synchronized 关键字，我们在定义Counter类的run()方法时可以按如下方法使用synchronized为部分代码加锁。

public void run(){

while(true){

synchronized (num){

num.increase();

}

}

}

同时在main()方法中调用testEqual()方法也用synchronized关键字修饰，这样得到的结果相同。

synchronized(num){

num.testEqual();

}

对象锁的获得和释放是由Java运行时系统自动完成的。

每个类也可以有类锁。类锁控制对类的synchronized static代码的访问。请看下面的例子：

public class X{

static int x, y;

static synchronized void foo(){

x++;

y++;

}

}

当foo()方法被调用时(如，使用X.foo())，调用线程必须获得X类的类锁。

3 线程间的同步控制

在多线程的程序中，除了要防止资源冲突外，有时还要保证线程的同步。下面通过生产者-消费者模型来说明线程的同步与资源共享的问题。

假设有一个生产者(Producer)，一个消费者(Consumer)。生产者产生0~9的整数，将它们存储在仓库(CubbyHole)的对象中并打印出这些数来；消费者从仓库中取出这些整数并将其也打印出来。同时要求生产者产生一个数字，消费者取得一个数字，这就涉及到两个线程的同步问题。

这个问题就可以通过两个线程实现生产者和消费者，它们共享CubbyHole一个对象。

如果不加控制就得不到预期的结果。

1. 不同步的设计

首先我们设计用于存储数据的类，该类的定义如下：

程序CubbyHole.java

class CubbyHole{

private int content ;

public synchronized void put(int value){

content = value;

}

public synchronized int get(){

return content ;

}

}

_____________________________________________________________________________▃

CubbyHole类使用一个私有成员变量content用来存放整数，put()方法和get()方法用来设置变量content的值。CubbyHole对象为共享资源，所以用synchronized关键字修饰。当put()方法或get()方法被调用时，线程即获得了对象锁，从而可以避免资源冲突。

这样当Producer对象调用put()方法是，它锁定了该对象，Consumer对象就不能调用get()方法。当put()方法返回时，Producer对象释放了CubbyHole的锁。类似地，当Consumer对象调用CubbyHole的get()方法时，它也锁定该对象，防止Producer对象调用put()方法。

接下来我们看Producer和Consumer的定义，这两个类的定义如下：

程序Producer.java

public class Producer extends Thread {

private CubbyHole cubbyhole;

private int number;

public Producer(CubbyHole c, int number) {

cubbyhole = c;

this.number = number;

}

public void run() {

for (int i = 0; i < 10; i++) {

cubbyhole.put(i);

System.out.println("Producer #" + this.number + " put: " + i);

try {

sleep((int)(Math.random() * 100));

} catch (InterruptedException e) { }

}

}

}

_____________________________________________________________________________▃

Producer类中定义了一个CubbyHole类型的成员变量cubbyhole，它用来存储产生的整数，另一个成员变量number用来记录线程号。这两个变量通过构造方法传递得到。在该类的run()方法中，通过一个循环产生10个整数，每次产生一个整数，调用cubbyhole对象的put()方法将其存入该对象中，同时输出该数。

下面是Consumer类的定义：

程序Consumer.java

public class Consumer extends Thread {

private CubbyHole cubbyhole;

private int number;

public Consumer(CubbyHole c, int number) {

cubbyhole = c;

this.number = number;

}

public void run() {

int value = 0;

for (int i = 0; i < 10; i++) {

value = cubbyhole.get();

System.out.println("Consumer #" + this.number + " got: " + value);

}

}

}

_____________________________________________________________________________▃

在Consumer类的run()方法中也是一个循环，每次调用cubbyhole的get()方法返回当前存储的整数，然后输出。

下面是主程序，在该程序的main()方法中创建一个CubbyHole对象c，一个Producer对象p1，一个Consumer对象c1，然后启动两个线程。

程序ProducerConsumerTest.java

public class ProducerConsumerTest {

public static void main(String[] args) {

CubbyHole c = new CubbyHole();

Producer p1 = new Producer(c, 1);

Consumer c1 = new Consumer(c, 1);

p1.start();

c1.start();

}

}

_____________________________________________________________________________▃

该程序中对CubbyHole类的设计，尽管使用了synchronized关键字实现了对象锁，但这还不够。程序运行可能出现下面两种情况：

如果生产者的速度比消费者快，那么在消费者来不及取前一个数据之前，生产者又产生了新的数据，于是消费者很可能会跳过前一个数据，这样就会产生下面的结果：Consumer: 3

Producer: 4

Producer: 5

Consumer: 5

…

反之，如果消费者比生产者快，消费者可能两次取同一个数据，可能产生下面的结果：Producer: 4

Consumer: 4

Consumer: 4

Producer: 5

…

2. 监视器模型

为了避免上述情况发生，就必须使生产者线程向CubbyHole对象中存储数据与消费者线程从CubbyHole对象中取得数据同步起来。为了达到这一目的，在程序中可以采用监视器(monitor)模型，同时通过调用对象的wait()方法和notify()方法实现同步。

下面是修改后的CubbyHole类的定义：

程序CubbyHole.java

class CubbyHole{

private int content ;

private boolean available=false;

public synchronized void put(int value){

while(available==true){

try{

wait();

}catch(InterruptedException e){}

}

content =value;

available=true;

notifyAll();

}

public synchronized int get(){

while(available==false){

try{

wait();

}catch(InterruptedException e){}

}

available=false;

notifyAll();

return content;

}

}

_____________________________________________________________________________▃

这里有一个boolean型的私有成员变量available用来指示内容是否可取。当available为true时表示数据已经产生还没被取走，当available为false时表示数据已被取走还没有存放新的数据。

当生产者线程进入put()方法时，首先检查available的值，若其为false，才可执行put()方法，若其为true，说明数据还没有被取走，该线程必须等待。因此在put()方法中调用CubbyHole对象的wait()方法等待。调用对象的wait()方法使线程进入等待状态，同时释放对象锁。直到另一个线程对象调用了notify()或notifyAll()方法，该线程才可恢复运行。

类似地，当消费者线程进入get()方法时，也是先检查available的值，若其为true，才可执行get()方法，若其为false，说明还没有数据，该线程必须等待。因此在get()方法中调用CubbyHole对象的wait()方法等待。调用对象的wait()方法使线程进入等待状态，同时释放对象锁。

上述过程就是监视器模型，其中CubbyHole对象为监视器。通过监视器模型可以保证生产者线程和消费者线程同步，结果正确。

程序的运行结果如下：

特别注意：wait()、notify()和notifyAll()方法是Object类定义的方法，并且这些方法只能用在synchronized代码段中。它们的定义格式如下：

?public final void wait()

?public final void wait(long timeout)

?public final void wait(long timeout, int nanos)

当前线程必须具有对象监视器的锁，当调用该方法时线程释放监视器的锁。调用这些方法使当前线程进入等待(阻塞)状态，直到另一个线程调用了该对象的notify()方法或notifyAll()方法，该线程重新进入运行状态，恢复执行。

timeout和nanos为等待的时间的毫秒和纳秒，当时间到或其他对象调用了该对象的notify()方法或notifyAll()方法，该线程重新进入运行状态，恢复执行。

wait()的声明抛出了InterruptedException，因此程序中必须捕获或声明抛出该异常。

?public final void notify()

?public final void notifyAll()

唤醒处于等待该对象锁的一个或所有的线程继续执行，通常使用notifyAll()方法。

在生产者/消费者的例子中，CubbyHole类的put和get方法就是临界区。当生产者修改它时，消费者不能问CubbyHole对象；当消费者取得值时，生产者也不能修改它。

java基础笔试测试题与答案

Java 一章至五章考试 一. 填空题(8 分) 1. 面向对象的三大原则是( 封装),( 继承) 和( 多态).2 分 2. 如果想在对象实例化的同时就初始化成员属性，则使用( 构造函数).2 分 3. ( 实体) 方法和( 构造) 方法不能修饰为abstract ？２分 二．选择题(60 分) 1) 在Java 语言中，下列（a,d ）是不满足命名规范的变量名。（选择二项） a) 姓名 b) $Name c) _instanceof d) instanceof 2) 下列Java 代码片段的输出结果是( a ) 。 char c='a'; int i=c; float f=i; byte b=(byte)c; System.out.println(c+","+i+","+f+","+b); a) 编译错误 b) a,97,97,97 c) a,97,97.0,97 d) a,97,97.0f,97 3) 下列Java 代码中，空白处的代码是（b,c ）。( 选择两项) public interface Fee{ public float calLabFee(float unitPrice, float time); } public class FeeImpl implements Fee { public float calLabFee(float unitPrice, float time){ return unitPrice * time; } } public class FeeInterfaceTest { public static void main(String[] args){ ________________ Float labFee = fee.calLabFee(400.00,5); } }

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 9 D. 编译通过，运行无输出 4、有关线程的叙述正确的有： ( ) A. 通过继承Thread类或实现Runnable接口，可以获得对类中方法的互斥锁定。 B. 可以获得对任何对象的互斥锁定。 C. 线程通过调用对象的synchronized 方法可取得对象的互斥锁定。 D. 线程调度算法是平台独立的。 5、以下哪个是线程类的方法? A. yield() B. sleep(long msec) C. go() D. stop() 6、以下哪个最准确描述synchronized 关键字?

16.JAVA网络编程实验 多线程

Java网络编程实验报告 （实验六） 学号：姓名： 实验项目名称：多线程教师评分： 一、实验目的 （1）了解线程的概念。 （2）学习简单的多线程编程。 二、预习内容及要求（要求写出预习内容） 1.进程和线程的概念 进程是程序一次动态执行的过程，对应从代码加载、执行到执行结束这样一个完整的过程，也是进程自身从产生、发展到消亡的过程。 线程是比进程更小的执行单元，一个进程在执行过程中，可以产生多个线程。每个线程都有自身的产生、执行和消亡的过程。 2.线程的状态与生命周期 ●新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。此 时它已经有了相应的内存空间和其他资源。 ●运行：线程创建之后就具备了运行的条件，一旦轮到它来享用CPU资源时，即JVM将CPU 使用权切换给该线程时，此线程的就可以脱离创建它的主线程独立开始自己的生命周期了(即 run方法执行的过程)。 ●中断：有4种原因的中断，CPU资源从当前线程切换给其他线程、执行了sleep(int millsecond) 方法、执行了wait()方法、进入阻塞状态。 ●死亡：run方法结束。 3.线程的创建 在Java语言中，与线程支持密切相关的是https://www.sodocs.net/doc/148392773.html,ng.Thread类和https://www.sodocs.net/doc/148392773.html,ng.Runnable接口。Runnable 接口定义很简单，只有一个run方法。任何一个类如果希望自己的实例能够以线程的形式执行，都可以来实现Runnable接口。 继承Thread类和实现Runnable接口，都可以用来创建Thread对象，效果上并没有什么不同。继承Thread类的方法很明显的缺点就是这个类不能再继承其他的类了，而实现Runnable接口不会有这个麻烦。 另外，在继承Thread类的代码中，this其实就是指当前正在运行的线程对象，如果使用实现Runnable 接口的方式，要得到当前正在执行的线程，需要使用Thread.currentThread()方法。 线程创建后仅仅是占有了内存资源，在JVM管理的线程中还没有这个线程，此线程必须调用start （）方法（从父类继承的方法）通知JVM，这样JVM就会知道又有一个新一个线程排队等候切换了。

java多线程面试题

java多线程面试题 1.什么是多线程编程？什么时候使用？ 多线程一般用于当一个程序需要同时做一个以上的任务。多线程通常用于GUI交互程序。一个新的线程被创建做一些耗时的工作，当主线程保持界面与用户的交互。 2.为什么wait(),notify()和notifyall()函数定义在Object类里面? 因为所有类都是继承于Object类，这样所有类就可以简单的进行多线程编程了。 3.wait()方法和sleep()方法有什么不同？ sleep()方法执行后仍然拥有线程，只是延时。而wait方法放弃了线程控制，其它线程可以运行，想要再次运行是要重新开始。 4.Thread和Runnable有什么不同？ JA V A线程控制着程序执行的主路径。当你用java命令调用JVM时，JVM创建了一个隐式线程来执行main方法。Thread类提供了主线程调用其它线程并行运行的机制。 Runnable接口定义了一个能被Thread运行的类。实现Runnable的类只需要实行run方法。可以很灵活的扩展现在的已经继承自其它父类的类。而thread则不可以，因为java 只允许继承一个父类。 Runnable可以共享数据，Thread是一个类，而Runnable是一个接口 5.我可以重载start()方法么？ 可以重载，重载后还要重载run（）方法， 9.编译运行下面的代码会发生什么？ 1.public class Bground extends Thread{ 2.public static void main(String argv[]) 3.{ 4. Bground b = new Bground(); 5. b.run(); 6.} 7.public void start()

《JAVA语言程序设计》期末考试试题及答案(2)

《JA V A语言程序设计》期末考试试题及答案 一、单选题 1、下列程序段执行后的结果是( A )。 String s = new String("abcdefg"); for (int i=0; i

8-实验八Java多线程操作(实验报告内容)

实验八 Java多线程操作 （实验报告） 一、目的 1．掌握Java多线程操作。 二、实验内容 启动线程，线程休眠，线程同步，等待和唤醒 三、实验环境 JDK1.6+dos环境 四、实验原理 通过案例掌握多线程操作。 五、实验步骤 1、设计一个线程操作类，要求可以产生三个线程对象，并可以分 别设置三个线程的休眠时间，如下所示： 线程A，休眠10秒 线程B，休眠20秒 线程C，休眠30秒 2、生产者与消费者问题，生产者生产一台电脑，消费者马上将生 产出的电脑取走。 六、实验小结 1、class MyThread implements Runnable{

String name; int time; public MyThread(String name,int time){ https://www.sodocs.net/doc/148392773.html,=name; this.time=time; } public void run(){ try{ Thread.sleep(this.time); } catch(Exception e){ } System.out.println(https://www.sodocs.net/doc/148392773.html,+"线程,休眠"+this.time/1000+"秒"); } } public class Demo08{ public static void main(String args[]){ MyThread mt1=new MyThread("线程A",10000); MyThread mt2=new MyThread("线程B",20000); MyThread mt3=new MyThread("线程C",30000);

JAVA 面试题总览(书签完整版)

JAVA面试题总览 JAVA基础 1.JAVA中的几种基本数据类型是什么，各自占用多少字节。 2.String类能被继承吗，为什么。 3.String，Stringbuffer，StringBuilder的区别。 4.ArrayList和LinkedList有什么区别。 5.讲讲类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数， 字段，当new的时候，他们的执行顺序。 6.用过哪些Map类，都有什么区别，HashMap是线程安全的吗,并发下使用的Map是什么， 他们内部原理分别是什么，比如存储方式，hashcode，扩容，默认容量等。 7.JAVA8的ConcurrentHashMap为什么放弃了分段锁，有什么问题吗，如果你来设计， 你如何设计。 8.有没有有顺序的Map实现类，如果有，他们是怎么保证有序的。 9.抽象类和接口的区别，类可以继承多个类么，接口可以继承多个接口么,类可以实现多个接 口么。 10.继承和聚合的区别在哪。 11.IO模型有哪些，讲讲你理解的nio，他和bio，aio的区别是啥，谈谈reactor模型。 12.反射的原理，反射创建类实例的三种方式是什么。 13.反射中，Class.forName和ClassLoader区别。 14.描述动态代理的几种实现方式，分别说出相应的优缺点。 15.动态代理与cglib实现的区别。 16.为什么CGlib方式可以对接口实现代理。 17.final的用途。 18.写出三种单例模式实现。 19.如何在父类中为子类自动完成所有的hashcode和equals实现？这么做有何优劣。 20.请结合OO设计理念，谈谈访问修饰符public、private、protected、default在应 用设计中的作用。 21.深拷贝和浅拷贝区别。 22.数组和链表数据结构描述，各自的时间复杂度。 23.error和exception的区别，CheckedException，RuntimeException的区别。 24.请列出5个运行时异常。 25.在自己的代码中，如果创建一个https://www.sodocs.net/doc/148392773.html,ng.String类，这个类是否可以被类加载器加 载？为什么。

Java笔试题及答案

Java笔试题及答案 一、单项选择题 1.Java是从()语言改进重新设计。 A.Ada B.C++ C.Pasacal D.BASIC 答案：B 2.下列语句哪一个正确() A. Java程序经编译后会产生machine code B. Java程序经编译后会产生byte code C. Java程序经编译后会产生DLL D.以上都不正确 答案：B 3.下列说法正确的有() A. class中的constructor不可省略 B. constructor必须与class同名，但方法不能与class同名 C. constructor在一个对象被new时执行 D.一个class只能定义一个constructor 答案：C 详解：见下面代码，很明显方法是可以和类名同名的，和构造方法唯一的区别就是，构造方法没有返回值。 package net.study; public class TestConStructor { public TestConStructor() {

} public void TestConStructor() { } public static void main(String[] args) { TestConStructor testConStructor = new TestConStructor(); testConStructor.TestConStructor(); } } 4.提供Java存取数据库能力的包是() 答案：A 5.下列运算符合法的是() A.&& B.<> C.if D.:= 答案：A 详解： java 中没有<> := 这种运算符，if else不算运算符 6.执行如下程序代码 a=0;c=0; do{ --c; a=a-1; }while(a>0); 后，C的值是()

JAVA程序设计期末考试题(多套含答案)

《JA V A程序设计》期末考试试题（五） 一、单选题 1、当某一线程正处于休眠状态，而另一个线程用Thread 类中的interrupt() 方法中断它时，抛出的异常类型是（）。 A) IOException B) RuntimeException C) InterruptedException D) ClassNotFoundException 2、下面的程序段的功能是( )。 File file1=new File("d:\\xxx\\yyy\\zzz"); file1.mkdirs(); A)在当前目录下生成子目录：\xxx\yyy\zzz B)生成目录：e:\xxx\yyy\zzz C)在当前目录下生成文件xxx.yyy.zzz D)以上说法都不对 3、应用程序的main方法中有以下语句，则输出的结果是( )。 String s = "xxxxxxxxxxxxxxx#123#456#zzzzz"; int n = s.indexOf("#"); int k = s.indexOf("#", n+1); String s2 = s.substring(n+1, k); System.out.println(s2); A) 123456 B) 123 C) xxxxxxxxxxxxxxx D) zzzzz 4、关于下面的程序Test.java说法正确的是( )。 public class Test { String x="1"; int y; public static void main(String args[]) { int z=2; System.out.println(x+y+z); } } A)3 B)102 C) 12 D)程序有编译错误 5、应用程序的main方法中有以下语句，则输出的结果是( )。

高级java实验三

实验三：基于多线程的Socket通信 班级：计科F1202 姓名：黄浩翔学号：201216010110 实验目的：通过将Socket通信和多线程的知识结合应用，掌握基于多线程的通信设计方法。 实验内容：创建客户端Socket；创建服务器端Socket；建立基于多线程的服务器段监听和数据处理机制；Socket的启动和管理。 实验步骤： //服务端 package基于多线程Socket通信; import https://www.sodocs.net/doc/148392773.html,.ServerSocket; import https://www.sodocs.net/doc/148392773.html,.Socket; public class MultiServer { public static void main(String args[]) { ServerSocket server=null; int count=0; boolean listening =true; try{ try{ server =new ServerSocket(6000);

System.out.println("服务器启动:"); } catch (Exception e){ System.out.println("不能接听服务"); } while(listening){ Socket socket=server.accept(); count++; System.out.println("Accept "+count+" Client!"); Thread read = new ReadThread(socket,"[client"+count+"]"); read.start(); } server.close(); } catch (Exception e){ System.out.println("Error:" + e); } } } //多线程 package基于多线程Socket通信; import java.io.BufferedReader;

多线程常见面试题

1)现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完 后执行？ T1.start(); T1.join(); T2.start(); T2.join(); T3.start() 2)11) 为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run() 方法？ start()方法最本质的功能是从CPU中申请另一个线程空间来执行run()方法中的代码,它和当前的线程是两条线,在相对独立的线程空间运行 ,也就是说,如果你直接调用线程对象的run()方法,当然也会执行,但那是在当前线程中执行,run()方法执行完成后继续执行下面的代码.而调用start()方法后,run()方法的代码会和当前线程并发(单CPU)或并行(多CPU)执行。 调用线程对象的run方法不会产生一个新的线程 3)在java中wait和sleep方法的不同？ sleep()睡眠时，保持对象锁，仍然占有该锁； 而wait()睡眠时，释放对象锁。 sleep()使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会; sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。 在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。 wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问； wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。 wiat()必须放在synchronized block中，否则会在program runtime时扔出”https://www.sodocs.net/doc/148392773.html,ng.IllegalMonitorStateException“异常。 4)为什么wait, notify 和notifyAll这些方法不在thread类里面？ 因为这些是关于锁的 而锁是针对对象的 锁用于线程的同步应用 决定当前对象的锁的方法就应该在对象中吧 我是这么理解的希望对你有帮助

java笔试题及答案.doc

java笔试题及答案 有了下面java笔试题及答案，进行java笔试时就容易多了，请您对下文进行参考： 1、作用域public，private，protected，以及不写时的区别 答：区别如下： 作用域当前类同一package子孙类其他package public 7 7 7 7 protected 7 7 7 X friendly 7 7 X X private 7 X X X 不写时默认为friendly 2、Anonymouslnner Class （匿名内部类）是否可以exte nd s （继承）其它类，是否可以imple ment s （实现）i nterf ace （接口） 答：匿名的内部类是没有名字的内部类。不能exte n ds （继承）其它类，但一个内部类可以作为一个接口，由另一个内部类实现 3、Sta ti cNestedC las s 和Inner Clas s 的不同答： Nes tedC lass （一般是C+ +的说法），In ne rClass （—般是JAVA的说法）。J ava内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。注：静态内部类（I

nn erClass）意味着1创建一个st atic内部类的对象，不需要一个外部类对象，2不能从一个st atic内部类的一个对象访问一个外部类对象 4、和的区别 答：是位运算符，表示按位与运算，是逻辑运算符，表示遷辑与（and ） 5、Coll ect ion 和Col lect ions 的区别 答：Coll ect ion是集合类的上级接口，继承与他的接口主要有Set和List. Col lections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作 6、什么时候用assert 答：asserti on （断言）在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，a ssertion 就是在程序中的一条语句，它对一个boolea n表 达式进行检查，一个正确程序必须保证这个bool ean表达 式的值为tr ue;如果该值为fal se，说明程序己经处于不正确的状态下，系统将给出警告或退出。一般来说，

java多线程试题答案

多线程 一．选择题 1.下列说法中错误地一项是（） A.线程就是程序.线程是一个程序地单个执行流 B.多线程是指一个程序地多个执行流.多线程用于实现并发 2.下列哪个一个操作不能使线程从等待阻塞状态进入对象阻塞状态（） A.等待阴塞状态下地线程被()唤 B.等待阻塞状态下地纯种被()中断 C.等待时间到 D.等待阻塞状态下地线程调用()方法 3.下列哪个方法可以使线程从运行状态进入其他阻塞状态（） A. 4.下列说法中错误地一项是（） A.一个线程是一个类地实例 B.线程从传递给纯种地实例()方法开始执行 C.线程操作地数据来自实例 D.新建地线程调用()方法就能立即进入运行状态 5.下列关于类提供地线程控制方法地说法中，错误地一项是（） A.在线程中执行线程地()方法，则线程等待直到执行完成 B.线程通过调用()方法来中断其阻塞状态 C.若线程调用方法()返回值为，则说明正在执行中 D.()方法返回当前线程地引用 6.下列说法中，错误地一项是（） A.对象锁在()语句执行完之后由持有它地线程返还 B.对象锁在()语句中出现异常时由持有它地线程返还 C.当持有锁地线程调用了该对象地()方法时，线程将释放其持有地锁 D.当持有锁地线程调用了该对象地构造方法时，线程将释放其持有地锁 7.下面地哪一个关键字通常用来对对象地加锁，从而使得对对象地访问是排他地 A. 二．填空题 . 在操作系统中，被称做轻型地进程是线程 . 多线程程序设计地含义是可以将一个程序任务分成几个并行地任务 . 在程序中，()方法地实现有两种方式：实现接口和继承类.多个线程并发执行时，各个线程中语句地执行顺序是确定地，但是线程之间地相对执行顺序是不确定地 中地对象锁是一种独占地排他锁 .程序中可能出现一种情况：多个线种互相等待对方持有地锁，而在得到对方地锁之前都不会释放自己地锁，这就是死锁b5E2R。 .线程地优先级是在类地常数和之间地一个值 .处于新建状态地线程可以使用地控制方法是()和(). .一个进程可以包含多个线程 三．简答题

java多线程实验报告

java多线程实验报告 篇一：西北农林科技大学java多线程实验报告 实验7 多线程 1.实验目的 (1) 掌握Java多线程的概念和实现方法 (2) 掌握Java多线程的同步问题 2.实验内容 任务一：火车售票 假设有火车票1000张，创建10个线程模拟10个售票点，每个售票点100毫秒买一张票。打印出售票过程，注意使用synchronized确保同一张票只能卖出一次。程序运行结果见左图。 打开Eclipse Tickets.java public class Ticket extends Thread { int ticket =1000; String name =""; public void run(){ while(true){synchronized(name){ if(ticket "第" + Thread.currentThread().getName()+ "售票点卖出了第" + ticket-- + "张票"); } } } }} try{ } catch(InterruptedException e){ }

Thread.sleep(100); Test.java public class Test { } public static void main(String args[]){} Ticket t = new Ticket(); new Thread(t,"1").start(); new Thread(t,"2").start(); new Thread(t,"3").start(); new Thread(t,"4").start(); new Thread(t,"5").start(); new Thread(t,"6").start(); new Thread(t,"7").start(); new Thread(t,"8").start(); new Thread(t,"9").start(); new Thread(t,"10").start(); 任务二：银行存款 假设某家银行，它可接受顾客的汇款，每做一次汇款，便可计算出汇款的总额。现有两个顾客，每人都分3次，每次100元将钱到入。试编写一个程序，模拟实际作业。 程序如下： classCBank { private static int sum=0; public static void add(int n){ inttmp=sum; tmp=tmp+n;// 累加汇款总额 try{ Thread.sleep((int)(10000*Math.random())); //

Java经典面试题大全_带答案

Java经典面试题带答案一、单项选择题 1．Java是从（）语言改进重新设计。 A．Ada B．C++ C．Pasacal D．BASIC 答案：B 2．下列语句哪一个正确（） A．Java程序经编译后会产生machine code B．Java程序经编译后会产生byte code(字节码) C．Java程序经编译后会产生DLL D．以上都不正确 答案：B 3．下列说法正确的有（） A．class中的constructor不可省略 B．constructor必须与class同名，但方法不能与class同名C．constructor在一个对象被new时执行（构造器） D．一个class只能定义一个constructor 答案：C 4．提供Java存取数据库能力的包是（） A．Java.sql /sql/数据库还有Oracle 也是一种数据库 B．java.awt C．https://www.sodocs.net/doc/148392773.html,ng D．java.swing 答案：A 5．下列运算符合法的是（） A．&& B．<> C．if D．:= 答案：A 6．执行如下程序代码 a=0;c=0; do{ --c; a=a-1; }while(a>0); 后，C的值是（） A．0 B．1 C．-1 D．死循环

答案：C 7．下列哪一种叙述是正确的（） A．abstract修饰符可修饰字段、方法和类 B．抽象方法的body部分必须用一对大括号{}包住 C．声明抽象方法，大括号可有可无 D．声明抽象方法不可写出大括号 答案：D 8．下列语句正确的是（） A．形式参数可被视为localvariable B．形式参数可被字段修饰符修饰 C．形式参数为方法被调用时，真正被传递的参数 D．形式参数不可以是对象 答案：A 9．下列哪种说法是正确的（） A．实例方法可直接调用超类的实例方法 B．实例方法可直接调用超类的类方法 C．实例方法可直接调用其他类的实例方法 D．实例方法可直接调用本类的类方法 答案：D 二、多项选择题 1．Java程序的种类有（） A．类（Class） B．Applet C．Application D．Servlet 2．下列说法正确的有（） A．环境变量可在编译sourcecode时指定 B．在编译程序时，所能指定的环境变量不包括class path C．javac一次可同时编译数个Java源文件 D．javac.exe能指定编译结果要置于哪个目录（directory）答案：BCD 3．下列标识符不合法的有（） A．new B．$Usdollars C．1234 D．car.taxi 答案：ACD 4．下列说法错误的有（） A．数组是一种对象 B．数组属于一种原生类 C．intnumber=[]={31,23,33,43,35,63} D．数组的大小可以任意改变 答案：BCD 5．不能用来修饰interface的有（）

Java实验五线程

实验五线程 一实验要求 1、理解进程和线程概念； 2、掌握创建、管理和控制Java线程对象的方法； 3、了解并发执行的多线程存在的各种关系 二实验内容 1、使用线程对象或Timer定时器制作数字时钟标签组件，显示当前日期和时间，每秒刷新，将该标签添加到框架窗口。 import java.awt.FlowLayout; import java.text.SimpleDateFormat;//简单日期格式类 import java.util.Locate; import java.util.Timer;//一种工具，线程用其安排以后在后台线程中执行的任务 import java.util.TimerTask; import java.swing.JLabel; public class ShizhongJFrame extends JFrame{ { Public ShizhongJFrame(){ JFrame f=new JFrame（“数字时钟”）; f.setLayout(new FlowLayout()); f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); f.setSize(200,70); final JLable lable=new JLable; final SimpleDateFormat format=new SimpleDateFormat(“H:m:s”,Locate.CHINA); f.add(lable); Timer time=new Timer(); time.scheduleAtFixedRate(new TimerTask(){ Public void run(){ Label.setText(format.format(new Date(System.currentTimeMillis()))); } },0,1000); f.setVisible(true); } Public staic void main(String arg[]){ New ShizhogJFrame(); } } 三实验内容中遇到的问题、解决方法和体会。

精选大厂java多线程面试题50题

Java多线程50题 1)什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。 2)线程和进程有什么区别？ 线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据。更多详细信息请点击这里。 3)如何在Java中实现线程？ https://www.sodocs.net/doc/148392773.html,ng.Thread类的实例就是一个线程但是它需要调用https://www.sodocs.net/doc/148392773.html,ng.Runnable接口来执行，由于线程类本身就是调用的 Runnable接口所以你可以继承https://www.sodocs.net/doc/148392773.html,ng.Thread类或者直接调用Runnable接口来重写run()方法实现线程。 4)Thread类中的start()和run()方法有什么区别？ 这个问题经常被问到，但还是能从此区分出面试者对Java线程模型的理解程度。start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果不一样。当你

调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。 5)Java中Runnable和Callable有什么不同？ Runnable和Callable都代表那些要在不同的线程中执行的任务。Runnable从JDK1.0开始就有了，Callable是在JDK1.5增加的。它们的主要区别是Callable的call()方法可以返回值和抛出异常，而Runnable的run()方法没有这些功能。Callable可以返回装载有计算结果的Future对象。 6)Java内存模型是什么？ Java内存模型规定和指引Java程序在不同的内存架构、CPU 和操作系统间有确定性地行为。它在多线程的情况下尤其重要。 Java内存模型对一个线程所做的变动能被其它线程可见提供了保证，它们之间是先行发生关系。 ●线程内的代码能够按先后顺序执行，这被称为程序次序 规则。 ●对于同一个锁，一个解锁操作一定要发生在时间上后发 生的另一个锁定操作之前，也叫做管程锁定规则。 ●前一个对Volatile的写操作在后一个volatile的读操作之 前，也叫volatile变量规则。 ●一个线程内的任何操作必需在这个线程的start()调用之 后，也叫作线程启动规则。 ●一个线程的所有操作都会在线程终止之前，线程终止规

Java开发工程师笔试题(带答案)

Java开发工程师笔试试题 （请不要在试题上留任痕迹，所有答案均写在答题纸上） 一．编程题（共26分） 1.任意写出一种排序算法。（6分） public void sort(int [] array){ //代码区 } 2.求1+2+3+..n（不能使用乘除法、for 、while 、if 、else 、switch 、case 等关键字 以及条件判断语句）（8分） public int sum(int n){ //代码区 return 0; } 3.完成下面法，输入一个整数，输出如下指定样式图案。（12分） 输入：3， 输出： 1*2*3 7*8*9 4*5*6

输入：4 输出： 1*2*3*4 9*10*11*12 13*14*15*16 5*6*7*8 public void drawNumPic(int n){ //代码区 } 二．选择题（定项选择每题3分，不定项选择每题4分，共63分） 1.在基本JAVA类型中，如果不明确指定，整数型的默认是__类型，带小数的默认是__类型？( B ) A.int float B.int double C.long float D.long double 2.只有实现了__接口的类，其对象才能序列化( A ) A.Serializable B.Cloneable https://www.sodocs.net/doc/148392773.html,parable

D.Writeable 3.代码System. out. println(10 % 3 * 2)；将打印出？( B ) A. 1 B.2 C.4 D.6 4.以下程序运行的结果为( A ) public class Example extends Thread{ @Override public void run(){ try{ Thread.sleep(1000); }catch (InterruptedException e){ e.printStackTrace(); } System.out.print("run"); } public static void main(String[] args){ Example example=new Example(); example.run(); System.out.print("main"); } } A.run main B.main run C.main D.run E.不能确定 5.下面有关java实例变量,局部变量,类变量和final变量的说法，错误的是？( B ) A.实例变量指的是类中定义的变量，即类成员变量，如果没有初始化，会有默认值

java线程练习题及答案

线程与线程类 1 线程的概念 线程的概念来源于计算机的操作系统的进程的概念。进程是一个程序关于某个数据集的一次运行。也就是说，进程是运行中的程序，是程序的一次运行活动。 线程和进程的相似之处在于，线程和运行的程序都是单个顺序控制流。有些教材将线程称为轻量级进程(light weight process)。线程被看作是轻量级进程是因为它运行在一个程序的上下文内，并利用分配给程序的资源和环境。 作为单个顺序控制流，线程必须在运行的程序中得到自己运行的资源，如必须有自己的执行栈和程序计数器。线程内运行的代码只能在该上下文内。因此还有些教程将执行上下文(execution context)作为线程的同义词。 所有的程序员都熟悉顺序程序的编写，如我们编写的名称排序和求素数的程序就是顺序程序。顺序程序都有开始、执行序列和结束，在程序执行的任何时刻，只有一个执行点。线程（thread ）则是进程中的一个单个的顺序控制流。单线程的概念很简单，如图1所示。 多线程（multi-thread ）是指在单个的程序内可以同时运行多个不同的线程完成不同的任务，图2说明了一个程序中同时有两个线程运行。 图1 单线程程序示意图 图2 多线程程序示意图 有些程序中需要多个控制流并行执行。例如， for(int i = 0; i < 100; i++) System.out.println("Runner A = " + i); for(int j = 0; j < 100; j++ ) System.out.println("Runner B = "+j); 上面的代码段中，在只支持单线程的语言中，前一个循环不执行完不可能执行第二个循环。要使两个循环同时执行，需要编写多线程的程序。 很多应用程序是用多线程实现的，如Hot Java Web 浏览器就是多线程应用的例子。在Hot Java 浏览器中，你可以一边滚动屏幕，一边下载Applet 或图像，可以同时播放动画和声音等。 2 Thread 类和Runnable 接口 多线程是一个程序中可以有多段代码同时运行，那么这些代码写在哪里，如何创建线程对象呢? 首先，我们来看Java 语言实现多线程编程的类和接口。在https://www.sodocs.net/doc/148392773.html,ng 包中定义了Runnable 接口和Thread 类。

Java多线程实验报告

实验报告 课程名称： Java语言程序设计 姓名: 学号: 班级: 数学与计算机科学学院

数学与计算机科学学院实验报告实验名称：多线程 指导教师：日期：

if (isPrime) count++; } System.out.println(st + "~" + en + "之间共有" + count + "个质数"); } public static void main(String[] args) { UseThread thread1 = new UseThread(2, 1000); UseThread thread2 = new UseThread(1000, 2000); thread1.start(); thread2.start(); } } 第2题代码： public class Experiment14_2 { public static void main(String[] args) { MyThread t1 = new MyThread("T1"); MyThread t2 = new MyThread("T2"); t1.start(); t2.start(); System.out.println("活动线程数：" + Thread.activeCount()); System.out.println("main()运行完毕"); } } class MyThread extends Thread { public MyThread(String s) { super(s); } public void run() { for (int i = 1; i <= 3; i++) { System.out.println(getName() + "第" + i + "次运行"); try { sleep((int) (Math.random() * 100)); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(getName() + "结束"); } }