第8章多线程

最新推荐文章于 2022-12-20 20:07:16 发布

EthanMilk

最新推荐文章于 2022-12-20 20:07:16 发布

阅读量383

点赞数 1

分类专栏： java基础 Java语言概述编程入门文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_35426036/article/details/128141519

版权

java基础同时被 3 个专栏收录

15 篇文章 1 订阅

订阅专栏

Java语言概述

11 篇文章 0 订阅

订阅专栏

编程入门

9 篇文章 0 订阅

订阅专栏

java中有几种方法可以实现一个线程(jdk5.0之前)？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？

sleep() 和 wait() 有什么区别?

同步和异步有何异同，在什么情况下分别使用他们？举例说明。

启动一个线程是用run()还是start()?

当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

请说出你所知道的线程同步的方法。

多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?

线程的基本概念、线程的基本状态以及状态之间的关系

简述synchronized和java.util.concurrent.locks.Lock的异同？

案例：三个线程间的通讯

一、判断题

1.C 和 Java 都是多线程语言。（）

2.如果线程死亡，它便不能运行。（）

3.在 Java 中，高优先级的可运行线程会抢占低优先级线程。（）

4.程序开发者必须创建一个线程去管理内存的分配。（）

5.一个线程在调用它的 start 方法，之前，该线程将一直处于出生期。（）

6.当调用一个正在进行线程的 stop()方法时，该线程便会进入休眠状态。（）

7.如果线程的 run 方法执行结束或抛出一个不能捕获的例外，线程便进入等待状态。（）

8.一个线程可以调用 yield 方法使其他线程有机会运行。（）

二、选择题

1.Java 语言中提供了一个▁▁线程，自动回收动态分配的内存。

2.当▁▁方法终止时，能使线程进入死亡状态。

3.用▁▁方法可以改变线程的优先级。

4.线程通过▁▁方法可以使具有相同优先级线程获得处理器。

5.线程通过▁▁方法可以休眠一段时间，然后恢复运行。

6.▁▁方法使对象等待队列的第一个线程进入就绪状态。

7.方法 resume( )负责重新开始▁▁线程的执行。

8.▁▁方法可以用来暂时停止当前线程的运行。

Java为什么要引入线程机制，线程、程序、进程之间的关系是怎样的。

Runnable接口包括哪些抽象方法？Thread类有哪些主要域和方法？

创建线程有哪两种方式(jdk5.0之前)？试写出每种的具体的流程。比较两种创建方式的不同，哪个更优。

创建多线程题目

在{1}添加什么代码，可以保证如下代码输出100

利用多线程设计一个程序，同时输出 50 以内的奇数和偶数，以及当前运行的线程名。

建立线程有几种方法？

定义两个线程（一个用继承Thread类，一个用实现Runnable接口），定义一个测试类包括一个主函数调用两个子线程（具体实现自定）

模拟一个人生产50个玩具，每200毫秒生产一个，当生产到第20个时加入每秒吃1个馒头，共吃完3个后在接着生产的多线程。

编写龟兔赛跑多线程程序，设赛跑长度为100米，每跑完10米输出一次结果。

改进上题的龟兔赛跑程序，通过改变优先级，并减掉休眠时间，使得乌龟以迅雷不及掩耳的速度跑完100米。

在多线程中，为什么要引入同步机制?

启动两个线程对一个数字i操作

wait()、notify()、notifyAll()的作用分别是什么？

实现一个由A、B、C三个窗口同时销售100张票的系统，要求打印出每个窗口打印的售票情况，并且每个窗口不得连续售票。

模拟3个人排除买票，每人买1张票。售货员只有1张五元的钱，电影票5元一张，王大拿拿一张二十元的人民币排在谢大脚前面买票，谢大脚拿1张十元的人民币排在在赵四的前面买票，赵四拿1张五元的人民币排在最后。即最终的卖票次序是：谢大脚、赵四、王大拿

编写生产者消费者多线程程序，设有一个最大库存量为4的电视机仓库，生产10台电视机，一边生产一边销售（消费）。

多线程操作(50分)

例子：

当我以为我的代码很安全时，等等。。。

这是要闹哪样

Java基础知识图解

1 基本概念：程序、进程、线程

2 线程的创建和使用

练习

创建两个分线程，让其中一个线程输出1-100之间的偶数，另一个线程输出1-100之间的奇数。

补充：线程的分类

3 线程的生命周期

4 线程的同步

//DeadLock.java
class A {
	public synchronized void foo(B b) {
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了A实例的foo方法"); // ①
		try {
			Thread.sleep(200);
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用B实例的last方法"); // ③
		b.last();
	}

	public synchronized void last() {
		System.out.println("进入了A类的last方法内部");
	}
}

class B {
	public synchronized void bar(A a) {
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了B实例的bar方法"); // ②
		try {
			Thread.sleep(200);
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用A实例的last方法"); // ④
		a.last();
	}

	public synchronized void last() {
		System.out.println("进入了B类的last方法内部");
	}
}

public class DeadLock implements Runnable {
	A a = new A();
	B b = new B();

	public void init() {
		Thread.currentThread().setName("主线程");
		// 调用a对象的foo方法
		a.foo(b);
		System.out.println("进入了主线程之后");
	}

	public void run() {
		Thread.currentThread().setName("副线程");
		// 调用b对象的bar方法
		b.bar(a);
		System.out.println("进入了副线程之后");
	}

	public static void main(String[] args) {
		DeadLock dl = new DeadLock();
		new Thread(dl).start();
		dl.init();
	}
}

练习1

5 线程的通信

练习 2 模拟银行取钱的问题

6 JDK5.0新增线程创建方式

ThreadLock.java

import java.util.concurrent.locks.ReentrantLock;

class Window implements Runnable{
	int ticket = 100;
	private final ReentrantLock lock = new ReentrantLock();
	public void run(){
		
		while(true){
			try{
				lock.lock();
				if(ticket > 0){
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(ticket--);
				}else{
					break;
				}
			}finally{
				lock.unlock();
			}
		}
	}
}

public class ThreadLock {
	public static void main(String[] args) {
		Window t = new Window();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		
		t1.start();
		t2.start();
	}
}

ThreadNew.java

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/*创建多线程的方式：
1.继承Thread
2.实现Runnable
3.实现Callable
4.使用线程池

*/
class MyThread01 extends Thread {
    @Override
    public void run() {
        System.out.println("-----MyThread01");
    }
}

class MyThread02 implements Runnable {
    public void run() {
        System.out.println("-----MyThread02");
    }
}

class MyThread03 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("-----MyThread03");
        return 200;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        new MyThread01().start();
        new Thread(new MyThread02()).start();

        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread03());
        new Thread(futureTask).start();
        try {
            Integer value = futureTask.get();
            System.out.println(value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//创建并使用多线程的第四种方法：使用线程池
class MyThread implements Runnable {

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}

}

public class ThreadPool {
	public static void main(String[] args) {
		// 1.调用Executors的newFixedThreadPool(),返回指定线程数量的ExecutorService
		ExecutorService pool = Executors.newFixedThreadPool(10);
		// 2.将Runnable实现类的对象作为形参传递给ExecutorService的submit()方法中，开启线程
		// 并执行相关的run()
		pool.execute(new MyThread());
		pool.execute(new MyThread());
		pool.execute(new MyThread());
		// 3.结束线程的使用
		pool.shutdown();

	}
}

章节练习题及面试题

java中有几种方法可以实现一个线程(jdk5.0之前)？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？

答：有两种实现方法，分别是继承Thread类与实现Runnable接口。

用synchronized关键字修饰同步方法，反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。

suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，

指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

sleep() 和 wait() 有什么区别?

答：sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。

wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

同步和异步有何异同，在什么情况下分别使用他们？举例说明。

答：如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。

当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

启动一个线程是用run()还是start()?

答：启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法就是正常的对象调用方法的执行，并不是使用分线程来执行的。

当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

答：不能，一个对象的一个synchronized方法只能由一个线程访问。

请说出你所知道的线程同步的方法。

答：wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

notityAll():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?

答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口

同步的实现方面有两种，分别是synchronized,wait与notify

线程的基本概念、线程的基本状态以及状态之间的关系

答：线程指在程序执行过程中，能够执行程序代码的一个执行单位，每个程序至少都有一个线程，也就是程序本身。

Java中的线程有四种状态分别是：创建、就绪、运行、阻塞、结束

简述synchronized和java.util.concurrent.locks.Lock的异同？

答：主要相同点：Lock能完成synchronized所实现的所有功能

主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。

案例：三个线程间的通讯

public class Demo01 {

public static void main(String[] args) {

//三个线程间的通讯

MyTask task = new MyTask();

new Thread(){

public void run() {

while(true){

try {

task.task1();

} catch (InterruptedException e1) {

e1.printStackTrace();

}

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

};

}.start();

new Thread(){

public void run() {

while(true){

try {

task.task2();

} catch (InterruptedException e1) {

e1.printStackTrace();

}

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

};

}.start();

new Thread(){

public void run() {

while(true){

try {

task.task3();

} catch (InterruptedException e1) {

e1.printStackTrace();

}

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

};

}.start();

}

class MyTask{

//标识 1:可以执行任务1，2:可以执行任务2, 3:可以执行任务3

int flag = 1;

public synchronized void task1() throws InterruptedException{

if(flag != 1){

this.wait();//当前线程等待

//this.wait(timeout);

}

System.out.println("1.银行信用卡自动还款任务...");

flag = 2;

//this.notify();//唤醒随机线程

this.notifyAll();//唤醒所有等待线程

}

public synchronized void task2() throws InterruptedException{

if(flag != 2){

this.wait();//线程等待

}

System.out.println("2.银行储蓄卡自动结算利息任务...");

flag = 3;

//this.notify();//唤醒其它线程

this.notifyAll();

}

public synchronized void task3() throws InterruptedException{

if(flag != 3){

this.wait();//线程等待

}

System.out.println("3.银行短信提醒任务...");

flag = 1;

//this.notify();//唤醒其它线程

this.notifyAll();

}

一、判断题

1.C 和 Java 都是多线程语言。（）

2.如果线程死亡，它便不能运行。（）

3.在 Java 中，高优先级的可运行线程会抢占低优先级线程。（）

4.程序开发者必须创建一个线程去管理内存的分配。（）

5.一个线程在调用它的 start 方法，之前，该线程将一直处于出生期。（）

6.当调用一个正在进行线程的 stop()方法时，该线程便会进入休眠状态。（）

7.如果线程的 run 方法执行结束或抛出一个不能捕获的例外，线程便进入等待状态。（）

8.一个线程可以调用 yield 方法使其他线程有机会运行。（）

【答案】

1.难度：容易

答案：错误

知识点：C 是单线程语言。

2.难度：容易

答案：正确

知识点：线程死亡就意味着它不能运行。

3.难度：适中

答案：正确

知识点：线程优先级的使用。

4.难度：适中

答案：错误

知识点：Java 提供了一个系统线程来管理内存的分配。

5.难度：容易

答案：正确

知识点：出生期的概念。

6.难度：适中

答案：错误

知识点：应该是 sleep 方法。

7.难度：适中

答案：错误

知识点：如果线程的 run 方法执行结束或抛出一个不能捕获的例外，线程便进入死亡状态。

8.难度：适中

答案：正确

知识点：yield 方法总是让高优先级的就绪线程先运行。

二、选择题

1.Java 语言中提供了一个▁▁线程，自动回收动态分配的内存。

A 异步

B 消费者

C 守护

D 垃圾收集

2.当▁▁方法终止时，能使线程进入死亡状态。

A run

B setPrority

C yield

D sleep

3.用▁▁方法可以改变线程的优先级。

A run

B setPrority

C yield

D sleep

4.线程通过▁▁方法可以使具有相同优先级线程获得处理器。

A run

B setPrority

C yield

D sleep

5.线程通过▁▁方法可以休眠一段时间，然后恢复运行。

A run

B setPrority

C yield

D sleep

6.▁▁方法使对象等待队列的第一个线程进入就绪状态。

A run

B notify

C yield

D sleep

7.方法 resume( )负责重新开始▁▁线程的执行。

A 被 stop( )方法停止

B 被 sleep( )方法停止

C 被 wait( )方法停止

D 被 suspend( )方法停止

8.▁▁方法可以用来暂时停止当前线程的运行。

A stop( )

B sleep( )

C wait( )

D suspend()

【答案】

1.难度：容易

答案：D

知识点：垃圾线程的使用。

2.难度：容易

答案：A

知识点：run 方法的使用。

3.难度：容易

答案：B

知识点：setPrority 方法的使用。

4.难度：容易

答案：C

知识点：yield 方法的使用。

5.难度：容易

答案：D

知识点：sleep 方法的使用。

6.难度：容易

答案：B

知识点：notify 方法的使用。

7.难度：适中

答案：D

知识点：一个线程被用 suspend( )方法，将该线程挂起。并通过调用 resume( )方法来重新开始线程的执行。

但是该方法容易导致死锁，应尽量避免使用。

8.难度：适中

答案：BCD

知识点：当调用 stop( )方法后，当前的线程不能重新开始运行。

Java为什么要引入线程机制，线程、程序、进程之间的关系是怎样的。

答：线程可以彼此独立的执行，它是一种实现并发机制的有效手段，可以同时使用多个线程来完成不同的任务，并且一般用户在使用多线程时并不考虑底层处理的细节。

程序是一段静态的代码，是软件执行的蓝本。进程是程序的一次动态执行过程，即是处于运行过程中的程序。

线程是比进程更小的程序执行单位，一个进程可以启动多个线程同时运行，不同线程之间可以共享相同的内存区域和数据。多线程程序是运行时间后嗣可能出现在一个进程之内的、有一个以上线程同时运行的情况的程序。

Runnable接口包括哪些抽象方法？Thread类有哪些主要域和方法？

答：Runnable接口中仅有run()抽象方法。

Thread类主要域有：MAX_PRIORITY,MIN_PRIORITY,NORM_PRIORITY。

主要方法有start(),run(),sleep(),currentThread(),setPriority(),getPriority(),join()等。

创建线程有哪两种方式(jdk5.0之前)？试写出每种的具体的流程。比较两种创建方式的不同，哪个更优。

1—继承Thread类

1) 定义类继承Thread类。

2) 覆盖Thread类中的run方法。

3) 创建Thread子类对象，即创建了线程对象。

4) 调用线程对象start方法：启动线程，调用run方法。

2—实现Runnable接口

1）定义类，实现Runnable接口。

2）覆盖Runnable接口中的run方法。

3）通过Thread类建立线程对象。

4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法中。

5）调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

【区别】

继承Thread: 线程代码存放Thread子类run方法中。

实现Runnable：线程代码存在接口的子类的run方法。

【实现方法的好处】

1）避免了单继承的局限性

2）多个线程可以共享同一个接口子类的对象，非常适合多个相同线程来处理同一份资源。

创建多线程题目

编写一个继承Thread类的方式实现多线程的程序。该类MyThread有两个属性，一个字符串WhoAmI代表线程名，一个整数delay代表该线程随机要休眠的时间。构造有参的构造器，线程执行时，显示线程名和要休眠时间。

另外，定义一个测试类TestThread，创建三个线程对象以展示执行情况。

class MyThread extends Thread {

private String whoAmI;

private int delay;

public MyThread(String s, int d) {

whoAmI = s;

delay = d;

}

public void run() {

try {

sleep(delay);

} catch (InterruptedException ie) {

}

System.out.println("Hello!I am" + whoAmI + ",I slept" + delay + "milliseconds");

}

public class TestThread {

public static void main(String[] args) {

MyThread t1 = new MyThread("Thread-1", (int) (Math.random() * 100));

MyThread t2 = new MyThread("Thread-2", (int) (Math.random() * 100));

MyThread t3 = new MyThread("Thread-3", (int) (Math.random() * 100));

t1.start();

t2.start();

t3.start();

}

在{1}添加什么代码，可以保证如下代码输出100

提示：t.wait() 或 t.jion() 或 t.yield() 或 t.interrupt()？

public class Test {

public static void main(String[] args) {

MyThread m = new MyThread();

Thread t = new Thread(m);

t.start();

{1}

int j = m.i;

System.out.println(j);

}

class MyThread implements Runnable{

int i;

public void run(){

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

i=100;

}

答案：t.join()

----------------------------------------------------------------------------

利用多线程设计一个程序，同时输出 50 以内的奇数和偶数，以及当前运行的线程名。

public class ThreadPrint extends Thread {

int k = 1;

public void run() {

int i = k;

while (i < 50) {

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

i += 2;

}

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

}

public static void main(String[] args) {

ThreadPrint t1 = new ThreadPrint();

ThreadPrint t2 = new ThreadPrint();

t1.k = 1;

t2.k = 2;

t1.start();

t2.start();

}

建立线程有几种方法？

定义两个线程（一个用继承Thread类，一个用实现Runnable接口），定义一个测试类包括一个主函数调用两个子线程（具体实现自定）

模拟一个人生产50个玩具，每200毫秒生产一个，当生产到第20个时加入每秒吃1个馒头，共吃完3个后在接着生产的多线程。

编写龟兔赛跑多线程程序，设赛跑长度为100米，每跑完10米输出一次结果。

改进上题的龟兔赛跑程序，通过改变优先级，并减掉休眠时间，使得乌龟以迅雷不及掩耳的速度跑完100米。

在多线程中，为什么要引入同步机制?

启动两个线程对一个数字i操作

其中1个线程每次对i加1
另1个线程每次对i减1

各运行20次，结果i的值等于初始值。

wait()、notify()、notifyAll()的作用分别是什么？

实现一个由A、B、C三个窗口同时销售100张票的系统，要求打印出每个窗口打印的售票情况，并且每个窗口不得连续售票。

模拟3个人排除买票，每人买1张票。售货员只有1张五元的钱，电影票5元一张，王大拿拿一张二十元的人民币排在谢大脚前面买票，谢大脚拿1张十元的人民币排在在赵四的前面买票，赵四拿1张五元的人民币排在最后。即最终的卖票次序是：谢大脚、赵四、王大拿

编写生产者消费者多线程程序，设有一个最大库存量为4的电视机仓库，生产10台电视机，一边生产一边销售（消费）。

多线程操作(50分)

1)启动两个线程对一个数字i操作（10分）

2)其中1个线程每次对i加1（10分）

3)另1个线程每次对i减一（10分）

4)各运行20次，结果i的值等于初始值。（20分）

EthanMilk

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
第8章多线程

Java基础编程
复制链接

扫一扫

专栏目录

第8章多线程

例子：

Java基础知识图解

1 基本概念： 程序、进程、线程

2 线程的创建和使用

练 习

补充：线程的分类

3 线程的生命周期

4 线程的同步

练 习1

5 线程的通信

练 习 2 模拟银行取钱的问题

6 JDK5.0新增线程创建方式

ThreadLock.java

ThreadNew.java

章节练习题及面试题

java中有几种方法可以实现一个线程(jdk5.0之前)？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？

sleep() 和 wait() 有什么区别?

同步和异步有何异同，在什么情况下分别使用他们？举例说明。

启动一个线程是用run()还是start()?

当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

请说出你所知道的线程同步的方法。

多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?

线程的基本概念、线程的基本状态以及状态之间的关系

简述synchronized和java.util.concurrent.locks.Lock的异同 ？

案例：三个线程间的通讯

一、判断题

1.C 和 Java 都是多线程语言。（ ）

2.如果线程死亡，它便不能运行。（ ）

3.在 Java 中，高优先级的可运行线程会抢占低优先级线程。（ ）

4.程序开发者必须创建一个线程去管理内存的分配。（ ）

5.一个线程在调用它的 start 方法，之前，该线程将一直处于出生期。（ ）

6.当调用一个正在进行线程的 stop()方法时，该线程便会进入休眠状态。（ ）

7.如果线程的 run 方法执行结束或抛出一个不能捕获的例外，线程便进入等待状态。（ ）

8.一个线程可以调用 yield 方法使其他线程有机会运行。（ ）

二、选择题

1.Java 语言中提供了一个▁▁线程，自动回收动态分配的内存。

2.当▁▁方法终止时，能使线程进入死亡状态。

3.用▁▁方法可以改变线程的优先级。

4.线程通过▁▁方法可以使具有相同优先级线程获得处理器。

5.线程通过▁▁方法可以休眠一段时间，然后恢复运行。

6.▁▁方法使对象等待队列的第一个线程进入就绪状态。

7.方法 resume( )负责重新开始▁▁线程的执行。

8.▁▁方法可以用来暂时停止当前线程的运行。

Java为什么要引入线程机制，线程、程序、进程之间的关系是怎样的。

Runnable接口包括哪些抽象方法？Thread类有哪些主要域和方法？

创建线程有哪两种方式(jdk5.0之前)？试写出每种的具体的流程。比较两种创建方式的不同，哪个更优。

创建多线程题目

在{1}添加什么代码，可以保证如下代码输出100

利用多线程设计一个程序，同时输出 50 以内的奇数和偶数，以及当前运行的线程名。

建立线程有几种方法？

定义两个线程（一个用继承Thread类，一个用实现Runnable接口），定义一个测试类包括一个主函数调用两个子线程（具体实现自定）

模拟一个人生产50个玩具，每200毫秒生产一个，当生产到第20个时加入每秒吃1个馒头，共吃完3个后在接着生产的多线程。

编写龟兔赛跑多线程程序，设赛跑长度为100米，每跑完10米输出一次结果。

改进上题的龟兔赛跑程序，通过改变优先级，并减掉休眠时间，使得乌龟以迅雷不及掩耳的速度跑完100米。

在多线程中，为什么要引入同步机制?

启动两个线程对一个数字i操作

wait()、notify()、notifyAll()的作用分别是什么？

实现一个由A、B、C三个窗口同时销售100张票的系统，要求打印出每个窗口打印的售票情况，并且每个窗口不得连续售票。

编写生产者消费者多线程程序，设有一个最大库存量为4的电视机仓库，生产10台电视机，一边生产一边销售（消费）。

多线程操作(50分)

“相关推荐”对你有帮助么？

1 基本概念：程序、进程、线程

练习

练习1

练习 2 模拟银行取钱的问题

简述synchronized和java.util.concurrent.locks.Lock的异同？

1.C 和 Java 都是多线程语言。（）

2.如果线程死亡，它便不能运行。（）

3.在 Java 中，高优先级的可运行线程会抢占低优先级线程。（）

4.程序开发者必须创建一个线程去管理内存的分配。（）

5.一个线程在调用它的 start 方法，之前，该线程将一直处于出生期。（）

6.当调用一个正在进行线程的 stop()方法时，该线程便会进入休眠状态。（）

7.如果线程的 run 方法执行结束或抛出一个不能捕获的例外，线程便进入等待状态。（）

8.一个线程可以调用 yield 方法使其他线程有机会运行。（）