1.如果线程死亡，它便不能运行。（T）
2.在Java中，高优先级的可运行线程会抢占低优先级线程。（T ）
3.线程可以用yield方法使低优先级的线程运行。（F）
4...程序开发者必须创建一个线程去管理内存的分配。（F）
5.一个线程在调用它的start方法，之前，该线程将一直处于出生期。（T）
6.当调用一个正在进行线程的stop( )方法时，该线程便会进入休眠状态。（F）
7.一个线程可以调用yield方法使其他线程有机会运行。（T）
二、选择题
1.Java语言中提供了一个▁D▁线程，自动回收动态分配的内存。
A．异步
B．消费者
C．守护
D．垃圾收集
2.Java语言避免了大多数的▁C▁错误。
A．数组下标越界
B．算术溢出
C．内存泄露
D．非法的方法参数
3.有三种原因可以导致线程不能运行，它们是▁ACD▁▁。
A．等待
B．阻塞
C．休眠
D．挂起及由于I/O操作而阻塞
4.当▁A方法终止时，能使线程进入死亡状态。
A．run
B．setPrority
C．yield
D．sleep
5.用▁B▁方法可以改变线程的优先级。
A．run
B．setPrority
C．yield
D．sleep
6.线程通过▁C▁方法可以使具有相同优先级线程获得处理器。
A．run
B．setPrority
C．yield
D．sleep
7.线程通过▁D▁方法可以休眠一段时间，然后恢复运行。
A．run
B．setPrority
C．yield
8.方法resume( )负责重新开始▁D▁线程的执行。
A．被stop( )方法停止
B．被sleep( )方法停止
C．被wait( )方法停止
D．被suspend( )方法停止
9.▁BCD▁方法可以用来暂时停止当前线程的运行。
A．stop( )
B．sleep( )
C．wait( )
D．suspend( )
三、简述题
1.简述程序、进程和线程之间的关系？什么是多线程程序？
答：程序是一段静态的代码，它是应用软件执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行到执行完毕的一个完整过程。这个过程也是进程本身从产生、发展、到消亡的过程。线程是比进程更小的单位。一个进程在其执行过程中，可以产生多个线程，形成多个执行流。每个执行流即每个线程也有它自身的产生、存在和消亡的过程，也是一个动态的概念。多线程程序是指一个程序中包含多个执行流。
2.线程有哪几个基本状态？它们之间如何转化？简述线程的生命周期。
答：新建状态，可运行状态，运行状态，阻碍状态，终止状态。对线程调用各种控制方法，就使线程从一种状态转换到另一种状态。线程的生命周期从新建开始，在可运行、运行和其他阻碍中循环，在可运行、运行、对象锁阻塞、等待阻塞中循环，最终在运行后run()方法结束后终止。
3.什么是线程调度？Java的线程调度采用什么策略？
答：在单个CPU上以某种顺序运行多个线程，称为线程的调度。Java的线程调度策略是一种优先级的抢先式调度。Java基于线程的优先级选择高优先级的线程进行运行。该线程将持续运行，直到它终止运行，或其他高优先级线程称为可运行的。
4.如何在Java程序中实现多线程？
答：1：通过Thread类的构造方法
2：通过实现Runnable接口创建线程、
3：通过继承Thread类创建线程
5.试简述Thread类的子类或实现Runnable接口两种方法的异同？
答：采用继承Thread类方法使程序代码简单，并可以在run（）方法中直接调用线程的其他方法。而实现Runnable接口更符合面向对象设计的思想，因为从OO设计的角度，thread 类是虚拟CPU的封装，所以Thread的子类应该是关于CPU行为的类。但在继承Thread类之类构造线程的方法中，Thread类的子类大都是与CPU不相关的类。而实现Runnable接口的方法，将不影响Java类的体系，所以更加符合面向对象的设计思想。同时，实现了Runnable 接口的类可以用extends继承其他的类。
四、程序设计题
1.编写一个类，在类中定义：
A：一个整型属性
B：一个方法，在这个方法中给变量加1，并打印出这个变量的值然后创建5个线程，分别调用类中定义的方法
(注意线程的同步)
Java网络编程实验报告 （实验六） 学号：姓名： 实验项目名称：多线程教师评分： 一、实验目的 （1）了解线程的概念。 （2）学习简单的多线程编程。 二、预习内容及要求（要求写出预习内容） 1.进程和线程的概念 进程是程序一次动态执行的过程，对应从代码加载、执行到执行结束这样一个完整的过程，也是进程自身从产生、发展到消亡的过程。 线程是比进程更小的执行单元，一个进程在执行过程中，可以产生多个线程。每个线程都有自身的产生、执行和消亡的过程。 2.线程的状态与生命周期 ●新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。此 时它已经有了相应的内存空间和其他资源。 ●运行：线程创建之后就具备了运行的条件，一旦轮到它来享用CPU资源时，即JVM将CPU 使用权切换给该线程时，此线程的就可以脱离创建它的主线程独立开始自己的生命周期了(即 run方法执行的过程)。 ●中断：有4种原因的中断，CPU资源从当前线程切换给其他线程、执行了sleep(int millsecond) 方法、执行了wait()方法、进入阻塞状态。 ●死亡：run方法结束。 3.线程的创建 在Java语言中，与线程支持密切相关的是https://www.doczj.com/doc/3718358050.html,ng.Thread类和https://www.doczj.com/doc/3718358050.html,ng.Runnable接口。Runnable 接口定义很简单，只有一个run方法。任何一个类如果希望自己的实例能够以线程的形式执行，都可以来实现Runnable接口。 继承Thread类和实现Runnable接口，都可以用来创建Thread对象，效果上并没有什么不同。继承Thread类的方法很明显的缺点就是这个类不能再继承其他的类了，而实现Runnable接口不会有这个麻烦。 另外，在继承Thread类的代码中，this其实就是指当前正在运行的线程对象，如果使用实现Runnable 接口的方式，要得到当前正在执行的线程，需要使用Thread.currentThread()方法。 线程创建后仅仅是占有了内存资源，在JVM管理的线程中还没有这个线程，此线程必须调用start （）方法（从父类继承的方法）通知JVM，这样JVM就会知道又有一个新一个线程排队等候切换了。
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()
1. 有以下程序片段，下列哪个选项不能插入到行1。（ D ） 1. 2.public class Interesting{ 3.//do sth 4. } （只能有一个public修饰的class） A、import java.awt.*; B、package mypackage; C、class OtherClass{ } D、public class MyClass{ } 2. 以下哪项是接口的正确定义？（ B D ） A、interface B { void print(){};} (接口里的方法都是抽象的，不能有方法体) B、abstract interface B { void print() ;} C、abstract interface B extends A1,A2 //A1、A2为已定义的接口 { abstract void print(){ };} (同上) D、interface B { void print();} 1.接口可以声明为public(公共)或默认的访问权限。接口隐含表明是抽象的(abstract)的。 2.接口的方法默认即为public(公共)且是abstract(抽象)的. 3.接口中的变量默认即为public(公共), static(静态) and final(最终的)。 接口声明编译器如何解释呢 public interface Searchable {}public abstract interface Searchable {} abstract interface Searchable {}abstract interface Searchable {} interface Searchable {}abstract interface Searchable {}
实验八 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.doczj.com/doc/3718358050.html,=name; this.time=time; } public void run(){ try{ Thread.sleep(this.time); } catch(Exception e){ } System.out.println(https://www.doczj.com/doc/3718358050.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基础 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.doczj.com/doc/3718358050.html,ng.String类，这个类是否可以被类加载器加 载？为什么。
多线程 一．选择题 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。 .线程地优先级是在类地常数和之间地一个值 .处于新建状态地线程可以使用地控制方法是()和(). .一个进程可以包含多个线程 三．简答题
实验三：基于多线程的Socket通信 班级：计科F1202 姓名：黄浩翔学号：201216010110 实验目的：通过将Socket通信和多线程的知识结合应用，掌握基于多线程的通信设计方法。 实验内容：创建客户端Socket；创建服务器端Socket；建立基于多线程的服务器段监听和数据处理机制；Socket的启动和管理。 实验步骤： //服务端 package基于多线程Socket通信; import https://www.doczj.com/doc/3718358050.html,.ServerSocket; import https://www.doczj.com/doc/3718358050.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.doczj.com/doc/3718358050.html,ng.IllegalMonitorStateException“异常。 4)为什么wait, notify 和notifyAll这些方法不在thread类里面？ 因为这些是关于锁的 而锁是针对对象的 锁用于线程的同步应用 决定当前对象的锁的方法就应该在对象中吧 我是这么理解的希望对你有帮助
Java多线程技术及案例 进程和线程： 进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1–n个线程。 线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。 线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。 多进程是指操作系统能同时运行多个任务（程序）。 多线程是指在同一程序中有多个顺序流在执行。 Java中多线程的多种实现方式 Java中有多种多线程实现方法，主要是继承https://www.doczj.com/doc/3718358050.html,ng.Thread类的方法和 https://www.doczj.com/doc/3718358050.html,ng.Runnable接口的方法。 继承Thread类 Thread是https://www.doczj.com/doc/3718358050.html,ng包中的一个类，从这个类中实例化的对象代表线程，启动一个新线程需要建立一个Thread实例。 使用Thread类启动新的线程的步骤如下： 1.实例化Thread对象 2.调用start()方法启动线程 构造方法：
public Thread(String threadName); public Thread(); 例程： publicclass Thread1extends Thread{//定义一个类继承Thread privateint count=1000; publicvoid run(){//重写run方法 while(true){ System.out.print(count+" "); if(--count==0){ return; } } } publicstaticvoid main(String[] args){ Thread1 th1=new Thread1();//实例化继承了Thread的类 Thread1 th2=new Thread1(); th1.start();//调用start()方法， th2.start(); for(int i=0;i<1000;i++){ System.out.print("A "); } }
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 多线程编程练习题 [] 选择题 1．编写线程类，要继承的父类是： A：Object B：Runnable C：Serializable D：Thread E: Exception 答 2．编写线程类，可以通过实现那个接口来实现？ A：Runnable B：Throwable C：Serializable D：Comparable E：Cloneable 答： 4．一个线程通过什么方法将处理器让给另一个优先级别相同的线程？ A：wait B：yield C：join D：sleep E：stop 答： 5．如果要一个线程等待一段时间后再恢复执行此线程，需要调用什么方法？A：wait B：yield C：join D：sleep E：stop F：notify 答： 7.Runnable接口定义了如下哪些方法？ A: start() B: stop() C: resume() D: run()
E: suspend() 答： 8. 如下代码创建一个新线程并启动线程： Runnable target=new MyRunnable(); Thread myThread=new Thread(target); 问:如下哪些类可以创建target对象，并能编译正确？ A: public class MyRunnable extends Runnable { public void run(){} } B: public class MyRunnable extends Object { public void run() {} } C: public class MyRunnable implements Runnable {public void run() {}} D: public class MyRunnable extends Runnable {void run() {}} E: public class MyRunnable implements Runnable {void run() {}} 答： 9.给出代码如下： public class MyRunnable implements Runnable { public void run() { -------------------------------- } } 问在虚线处，如下哪些代码可以创建并启动线程？ A: new Runnable(MyRunnable).start(); B: new Thread(MyRunnable).run(); C: new Thread(new MyRunnable()).start(); D: new MyRunnable().start(); 答： [] 问答题 1.线程和进程有什么区别？ 2.Java创建线程的方式有哪些？ [] 编程题 1．编写多线程应用程序，模拟多个人通过一个山洞的模拟。这个山洞每次只能通过一个人，每个人通过山洞的时间为5秒，随机生成10个人，同时准备过此山洞，显示一下每次通过山洞人的姓名。 2．选做，目前有三个类，里面都有打印的方法，类A的该方法可以打印出10个A,类B的方法可以打印出10个B,类C的方法可以打印出10个C.请利用多线程（提示wait,notify）实现轮流打印出ABC.
实验五线程 一实验要求 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题 1)什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。 2)线程和进程有什么区别？ 线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据。更多详细信息请点击这里。 3)如何在Java中实现线程？ https://www.doczj.com/doc/3718358050.html,ng.Thread类的实例就是一个线程但是它需要调用https://www.doczj.com/doc/3718358050.html,ng.Runnable接口来执行，由于线程类本身就是调用的 Runnable接口所以你可以继承https://www.doczj.com/doc/3718358050.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语言程序设计 姓名: 学号: 班级: 数学与计算机科学学院
数学与计算机科学学院实验报告实验名称：多线程 指导教师：日期：
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() + "结束"); } }
ava最新常见面试题+ 答案汇总 1、面试题模块汇总 面试题包括以下十九个模块：Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql、Redis、JVM 。如下图所示： 可能对于初学者不需要后面的框架和JVM 模块的知识，读者朋友们可根据自己的情况，选择对应的模块进行阅读。 适宜阅读人群 需要面试的初/中/高级java 程序员 想要查漏补缺的人 想要不断完善和扩充自己java 技术栈的人 java 面试官 具体面试题 下面一起来看208 道面试题，具体的内容。 一、Java 基础 1.JDK 和JRE 有什么区别？ 2.== 和equals 的区别是什么？ 3.两个对象的hashCode()相同，则equals()也一定为true，对吗？ 4.final 在java 中有什么作用？ 5.java 中的Math.round(-1.5) 等于多少？ 6.String 属于基础的数据类型吗？ 7.java 中操作字符串都有哪些类？它们之间有什么区别？ 8.String str="i"与String str=new String(“i”)一样吗？ 9.如何将字符串反转？ 10.String 类的常用方法都有那些？ 11.抽象类必须要有抽象方法吗？ 12.普通类和抽象类有哪些区别？ 13.抽象类能使用final 修饰吗？
14.接口和抽象类有什么区别？ 15.java 中IO 流分为几种？ 16.BIO、NIO、AIO 有什么区别？ 17.Files的常用方法都有哪些？ 二、容器 18.java 容器都有哪些？ 19.Collection 和Collections 有什么区别？ 20.List、Set、Map 之间的区别是什么？ 21.HashMap 和Hashtable 有什么区别？ 22.如何决定使用HashMap 还是TreeMap？ 23.说一下HashMap 的实现原理？ 24.说一下HashSet 的实现原理？ 25.ArrayList 和LinkedList 的区别是什么？ 26.如何实现数组和List 之间的转换？ 27.ArrayList 和Vector 的区别是什么？ 28.Array 和ArrayList 有何区别？ 29.在Queue 中poll()和remove()有什么区别？ 30.哪些集合类是线程安全的？ 31.迭代器Iterator 是什么？ 32.Iterator 怎么使用？有什么特点？ 33.Iterator 和ListIterator 有什么区别？ 34.怎么确保一个集合不能被修改？
成绩： 面向对象原理与Java实践课程实验报告 实验6：多线程实验 姓名林浩强 班级网络14-2 学号 14034460220 实验地点软件实验室 实验时间 2016.6.7 指导教师姚明
一、实验目的： ●了解线程调度机制 ●理解线程同步机制 ●掌握线程设计方法 二、实验要求： ●掌握线程创建的方法 ●掌握线程的基本控制方法 ●掌握线程间的同步控制方法 三、实验内容： 1、随机生成1万个整数，利用线程技术计算两种不同排序算法对这些数排序的运行时间。 2、有一水塘，可实现注水和排水操作。当水塘无水时不能对其再进行排水操作，当水塘水满时不能对其再进行注水操作。创建水塘类Pond、注水线程Injection和排水线程Drain，假设注水线程可以在10分钟内将水塘注满水，排水线程可以在10分钟内将水塘的水全排出。试实现水塘的注水和排水过程。 四、设计思路： 首先，第一个实验的需求是随机生成10000个整数并且按两种算法排序，并利用线程的方式计算排序时间。我用的排序算法是冒泡排序和选择排序法，在排序的前后分别用System 类的CurrentTimeMillis()方法获取当前时间的毫秒值，作差求出排序所用的时间。最后在SortDemo类中启动线程即可。、 第二个实验的需求是实现注水和排水的操作，题目中指出“当水塘无水时不能对其再进行排水操作，当水塘水满时不能对其再进行注水操作”，所以我采用了线程的等待唤醒机制来实现。首先在Pond类中声明一个标记变量flag，把注水和排水的操作封装成为功能并加了同步关键字synchronize，方法中运用了同步唤醒机制实现依次的一次一个输出。然后在Injection类和Drain类中调用同步方法即可。最后，在PondDemo中启动线程即可。 五、程序源代码： 实验题目1： package java6_Test; import java.util.Random; public class Sort1 extends Thread { private Object obj = new Object(); //重写run方法 public void run() { //计时开始 long l1 = System.currentTimeMillis(); //用Object类对象设置同步锁 synchronized (obj) { //随机生成10000个数并用相应长度数组来储存这些数
15个Java多线程面试题及答案 1)现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行? 这个线程问题通常会在第一轮或电话面试阶段被问到，目的是检测你对”join”方法是否熟悉。这个多线程问题比较简单，可以用join方法实现。 2)在Java中Lock接口比synchronized块的优势是什么?你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它? lock接口在多线程和并发编程中最大的优势是它们为读和写分别提 供了锁，它能满足你写像ConcurrentHashMap这样的高性能数据结构和有条件的阻塞。Java线程面试的问题越来越会根据面试者的回答来提问。芯学苑老师强烈建议在你在面试之前认真读一下Locks，因为当前其大量用于构建电子交易终统的客户端缓存和交易连接空间。 3)在java中wait和sleep方法的不同?
通常会在电话面试中经常被问到的Java线程面试问题。最大的不同是在等待时wait会释放锁，而sleep一直持有锁。Wait通常被用于线程间交互，sleep通常被用于暂停执行。 4)用Java实现阻塞队列。 这是一个相对艰难的多线程面试问题，它能达到很多的目的。第一，它可以检测侯选者是否能实际的用Java线程写程序;第二，可以检测侯选者对并发场景的理解，并且你可以根据这个问很多问题。如果他用wait()和notify()方法来实现阻塞队列，你可以要求他用最新的Java 5中的并发类来再写一次。 5)用Java写代码来解决生产者——消费者问题。 与上面的问题很类似，但这个问题更经典，有些时候面试都会问下面的问题。在Java中怎么解决生产者——消费者问题，当然有很多解决方法，我已经分享了一种用阻塞队列实现的方法。有些时候他们甚至会问怎么实现哲学家进餐问题。 6)用Java编程一个会导致死锁的程序，你将怎么解决?
任务8 多线程编程 一、实验目的 1. 掌握线程的概念、线程的生命周期。 2. 掌握采用继承Thread 类创建子线程。 3. 掌握使用Runnable 接口使类线程化。 二、实验要求 1．掌握线程的概念、线程的生命周期。 2．掌握使用Runnable 接口使类线程化。 三、实验内容 一、输入以下源代码，多次运行程序，分析输出结果 1. 继承Thread 类创建子线程 public class MultiThreadExample{ public static void main(String []args){ new ThreadDemo("A").start();//启动线程A new 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 + " "); } } }
重庆交通大学综合性设计性实验报告 实验项目名称：进程调度（先来先服务） 实验项目性质： JAVA多线程 实验所属课程： JAVA程序设计 实验室(中心)：语音大楼 8 楼 801 班级：软件专业 2012级2班 姓名：尚亚* 学号： 631206050216 指导教师：杨 实验完成时间： 2014 年 11 月 25 日
一、实验目的 1、理解程序、线程和进程的概念； 2、理解多线程的概念； 3、掌握线程的各种状态； 4、熟练使用Thread类创建线程； 5、熟练使用线程各种方法； 6、掌握线程的调度及线程同步的实现原理。 二、实验内容及要求 进程调度是处理机管理的核心内容。本实验要求采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念。并体会了优先数和先来先服务调度算法的具体实施办法。 用JA V A语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。做一个能够直观体现多个进程时，CPU 是怎样调度就绪队列中的进程（按照先来先服务的原则）。
三、实验设备 PC机，windows7，eclipse。 四、设计方案 ㈠设计主要思想 （1）要模拟进程的调度算法，必须先体现处进程及系统资源。 （2）要体现先来先服务的算法，就必须表现出当有一个进程进入CPU时其他进程不能进入，并在就绪队列中排队。本实验建立了四个圆移动的线程表示作业调度，用圆在表示就绪队列的方框中停留表示进程在就绪队列中排队。 （3）当有一个圆移动到表示CPU的范围内时，让其它线程在就绪队列中排队，当CPU内无进程时，先来的圆先移动，以表示CPU 对进程的调度。 ㈡设计的主要步骤 （1）建立四个不同颜色的圆移动的线程，表示对四个进程的调度。 （2）当有一个表示进程的圆到达表示CPU范围内时，通过让其它几个圆停留在表示就绪队列的方框范围内，表示进程在就绪队列中排成队列。 （3）当第一个先到达的进程释放CPU，在排成队列的几个圆中选择先到达的圆，使其移动表示对先来的进程进行调度，直到所有的圆移动完毕。 五、主要代码 import java.awt.Font; import java.awt.event.*;