java中有几种方法可以实现一个线程？
46、java中有几种方式可以实现一个线程？用甚么关键字润饰同步要领?stop()和suspend()法子为什么不保举利用？
java5曩昔，有如下两种：
第一种：
newThread(){}.start();这默示挪用Thread子类工具的run要领，newThread(){}示意一个Thread的具名子类的实例工具，子类加之run方式后的代码如下：
newThread(){
publicvoidrun(){
}
}.start();
第二种：
newThread(newRunnable(){}).start();这示意挪用Thread工具担当的Runnable工具的run法子，newRunnable(){}表现一个Runnable的具名子类的实例工具,runnable的子
类加之run方式后的代码如下：
newThread(newRunnable(){
publicvoidrun(){
}
}
).start();
从java5起头，另有如下一些线程池建立多线程的体例：
ExecutorServicepool=Executors.newFixedThreadPool(3)
for(inti=0;i<10;i++)
{
pool.execute(newRunable(){publicvoidrun(){}});
}
Executors.newCachedThreadPool().execute(newRunable(){publicvoidrun(){}}); Executors.newSingleThreadExecutor().execute(newRunable(){publicvoidrun(){}}); 有两种实现方式，别离利用newThread()和newThread(runnable)情势，第一种直接挪用thread的run要领，以是，咱们每每利用Thread子类，即newSubThread()。第二
种挪用runnable的run要领。
有两种实现法子，别离是承继Thread类与实现Runnable接口
用synchronized关键字润饰同步方式
阻挡利用stop()，是由于它不平安。它会排除由线程获取的全部锁定，并且若是工具处于一种不联贯状况，那末其他线程能在那种状况下查抄和点窜它们。了局很难查抄
出真正的题目地点。suspend()法子轻易产生死锁。挪用suspend()的时辰，方针线程会停下来，但却依然持有在这以前得到的锁定。此时，其他任何线程都不能会见锁
定的资本，除非被\"挂起\"的线程规复运行。对任何线程来说，若是它们想恢复目的线程，同时又试图利用任何一个锁定的资本，就会造成死锁。以是不应该利用suspend()，
而应在本身的Thread类中置入一个标记，指出线程应该举止仍是挂起。若标记指出线程应该挂起，便用wait()命其进入期待状况。若标记指出线程理当规复，则用一
个notify()从头启动线程。
47、sleep()和wait()有甚么区别?
（网上的谜底：sleep是线程类（Thread）的法子，致使此线程停息实行指定时候，给实行机遇给其他线程，可是监控状况仍然连结，到时后会主动规复。挪用sleep
不会开释工具锁。wait是Object类的要领，对此工具挪用wait方式致使本线程抛却工具锁，进入期待此工具的守候锁定池，只有针对此工具发出notify法子（或notifyAll）
后本线程才进入工具锁定池筹备取得工具锁进入运行状况。）
sleep便是正在实行的线程自动让出cpu，cpu去实行其他线程，在sleep指定的时候事后，cpu才会回到这个线程上继承往下实行，要是当前线程进入了同步锁，sleep
要领并不会开释锁，纵然当前线程利用sleep法子让出了cpu，但其他被同步锁盖住了的线程也无法获得实行。wait是指在一个已经进入了同步锁的线程内，让本身临时让出
同步锁，以便其他正在等候此锁的线程可以获得同步锁并运行，只有其他线程挪用了notify 方式（notify并不开释锁，只是报告挪用过wait方式的线程可以去参预取得锁的
竞争了，但不是顿时获得锁，由于锁还在别人手里，别人还没开释。假如notify方式背面的代码另有得多，必要这些代码实行完后才会开释锁，可以在notfiy要领后增加一
个期待和一些代码，看看结果），挪用wait法子的线程就会排除wait状况和步伐可以再次获得锁后连续向下运行。对付wait的解说肯定要合营例子代码来申明，才显得本身
真清楚明明。
packagecom.huawei.interview;
publicclassMultiThread{
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
newThread(newThread1()).start();
try{
Thread.sleep(10);
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
newThread(newThread2()).start();
}
privatestaticclassThread1implementsRunnable
{
@Override
publicvoidrun(){
//TODOAuto-generatedmethodstub
//因为这里的Thread1和下面的Thread2内部run要领要用统一工具作为监视器，咱们这里不克不及用this，由于在Thread2内里的this和这个Thread1的this不是同一个工具。我
们用MultiThread.class这个字节码工具，当前假造机里引用这个恒量时，指向的都是同一个工具。
synchronized(MultiThread.class){
System.out.println(\"enterthread1...\");
System.out.println(\"thread1iswaiting\");
try{
//开释锁有两种方法，第一种体例是步伐天然分开监视器的规模，也就是分开了synchronized关键字统领的代码规模，另一种体式格局便是在synchronized关键字管辖的代码内部挪用监视器工具的wait方法。这里，利用wait方式开释锁。MultiThread.class.wait();
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
System.out.println(\"thread1isgoingon...\");
System.out.println(\"thread1isbeingover!\");
}
}
}
privatestaticclassThread2implementsRunnable
{
@Override
publicvoidrun(){
//TODOAuto-generatedmethodstub
synchronized(MultiThread.class){
System.out.println(\"enterthread2...\");
System.out.println(\"thread2notifyotherthreadcanreleasewaitstatus..\");
//因为notify方式并不开释锁，即便thread2挪用下面的sleep法子苏息了10毫秒，但thread1依然不会实行，由于thread2没有开释锁，以是Thread1无法得不到锁。MultiThread.class.notify();
System.out.println(\"thread2issleepingtenmillisecond...\");
try{
Thread.sleep(10);
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
System.out.println(\"thread2isgoingon...\");
System.out.println(\"thread2isbeingover!\");
}
}
}
}
48、同步和异步有何异同，在甚么情形下别离利用他们？举例阐明。
若是数据将在线程间同享。比方正在写的数据今后大概被另一个线程读到，大概正在读的数据大概已经被另一个线程写过了，那末这些数据便是同享数据，必需举行同步存
取。
当应用程序在工具上挪用了一个必要破费很永劫间来实行的要领，而且不进展让步伐守候要领的返回时，就应该利用异步编程，在很多情形下采纳异步路子每每更有效率。
49.下面两个法子同步吗？（本身发现）
classTest
{
synchronizedstaticvoidsayHello3()
{
}
synchronizedvoidgetX(){}
}
50、多线程有几种实现法子?同步有几种实现要领?
多线程有两种实现法子，别离是担当Thread类与实现Runnable接口
同步的实现方面有两种，划分是synchronized,wait与notify
wait():使一个线程处于等候状况，而且开释所持有的工具的lock。
sleep():使一个正在运行的线程处于就寝状况，是一个静态方式，挪用此方法要捕获InterruptedException非常。
notify():叫醒一个处于等候状况的线程，注重的是在挪用此方法的时刻，并不克不及切当的唤醒某一个守候状况的线程，而是由JVM确定叫醒哪一个线程，并且不是按优先级。Allnotity():叫醒全部处入期待状况的线程，留意并不是给全部叫醒线程一个工具的锁，而是让它们竞争。
文章来至：汉昌教育：https://www.doczj.com/doc/3712793953.html,
7Java多线程机制 7.1单项选择题 1. 线程调用了sleep（）方法后，该线程将进入（）状态。 A. 可运行状态 B. 运行状态 C. 阻塞状态 D. 终止状态 2. 关于java线程，下面说法错误的是（） A. 线程是以CPU为主体的行为 B. java利用线程使整个系统成为异步 C. 创建线程的方法有两种：实现Runnable接口和继承Thread类 D. 新线程一旦被创建，它将自动开始运行 3. 在java中的线程模型包含（） A. 一个虚拟处理器 B. CPU执行的代码 C. 代码操作的数据 D. 以上都是 4.在java语言中，临界区可以是一个语句块，或者是一个方法，并用（）关键字标识。 A. synchronized B. include C. import D. Thread 5. 线程控制方法中，yield()的作用是（） A. 返回当前线程的引用 B. 使比其低的优先级线程执行 C. 强行终止线程 D. 只让给同优先级线程运行 6. 线程同步中，对象的锁在（）情况下持有线程返回 A. 当synchronized()语句块执行完后 B. 当在synchronized()语句块执行中出现例外（exception）时 C. 当持有锁的线程调用该对象的wait()方法时 D. 以上都是 7. 在以下（）情况下，线程就进入可运行状态 A. 线程调用了sleep()方法时 B. 线程调用了join()方法时
C. 线程调用了yield()方法时 D. 以上都是 8. java用（）机制实现了进程之间的异步执行 A. 监视器 B. 虚拟机 C. 多个CPU D. 异步调用 类的方法中，toString()方法的作用是（） A. 只返回线程的名称 B. 返回当前线程所属的线程组的名称 C. 返回当前线程对象 D. 返回线程的名称 语言具有许多优点和特点,下列选项中,哪个反映了Java程序并行机制的特点（） A. 安全性 B. 多线程 C. 跨平台 D. 可移值 11.以下哪个关键字可以用来对对象加互斥锁？（） A. transient B. synchronized C. serialize D. static 12.下面关于进程、线程的说法不正确的是( )。 A．进程是程序的一次动态执行过程。一个进程在其执行过程中，可以产生多个线程——多线程，形成多条执行线索。 B．线程是比进程更小的执行单位，是在一个进程中独立的控制流，即程序内部的控制流。线程本身不能自动运行，栖身于某个进程之中，由进程启动执行。 C．Java多线程的运行与平台无关。 D．对于单处理器系统，多个线程分时间片获取CPU或其他系统资源来运行。对于多处理器系统，线程可以分配到多个处理器中，从而真正的并发执行多任务。 7.2填空题 1.________是java程序的并发机制，它能同步共享数据、处理不同的事件。 2.线程是程序中的一个执行流，一个执行流是由CPU运行程序的代码、__________所形 成的，因此，线程被认为是以CPU为主体的行为。 3.线程的终止一般可以通过两种方法实现：自然撤销或者是__________. 4.线程模型在java中是由__________类进行定义和描述的。 5.线程的创建有两种方法：实现_________接口和继承Thread类。 6.多线程程序设计的含义是可以将程序任务分成几个________的子任务。 7.按照线程的模型，一个具体的线程也是由虚拟的CPU、代码与数据组成，其中代码与数 据构成了___________,线程的行为由它决定。 8.ava中，新建的线程调用start()方法、如(),将使线程的状态从New(新建状态)转换为 _________。 9.多线程是java程序的________机制，它能同步共享数据，处理不同事件。 10.进程是由代码、数据、内核状态和一组寄存器组成，而线程是表示程序运行状态的
多线程 一．选择题 1.下列说法中错误的一项是（A） A.线程就是程序 B.线程是一个程序的单个执行流 B.多线程是指一个程序的多个执行流D.多线程用于实现并发 2.下列哪个一个操作不能使线程从等待阻塞状态进入对象阻塞状态（D） A.等待阴塞状态下的线程被notify()唤 B.等待阻塞状态下的纯种被interrput()中断 C.等待时间到 D.等待阻塞状态下的线程调用wait()方法 3.下列哪个方法可以使线程从运行状态进入其他阻塞状态（A） A.sleep B.wait C.yield D.start 4.下列说法中错误的一项是（D） A.一个线程是一个Thread类的实例 B.线程从传递给纯种的Runnable实例run()方法开始执行 C.线程操作的数据来自Runnable实例 D.新建的线程调用start()方法就能立即进入运行状态 5.下列关于Thread类提供的线程控制方法的说法中，错误的一项是（D） A.在线程A中执行线程B的join()方法，则线程A等待直到B执行完成 B.线程A通过调用interrupt()方法来中断其阻塞状态 C.若线程A调用方法isAlive()返回值为true，则说明A正在执行中 D.currentThread()方法返回当前线程的引用 6.下列说法中，错误的一项是（） A.对象锁在synchronized()语句执行完之后由持有它的线程返还 B.对象锁在synchronized()语句中出现异常时由持有它的线程返还 C.当持有锁的线程调用了该对象的wait()方法时，线程将释放其持有的锁 D.当持有锁的线程调用了该对象的构造方法时，线程将释放其持有的锁 7.下面的哪一个关键字通常用来对对象的加锁，从而使得对对象的访问是排他的A A.sirialize B transient C synchronized D static 二．填空题 1.在操作系统中，被称做轻型的进程是线程 2.多线程程序设计的含义是可以将一个程序任务分成几个并行的任务 3.在Java程序中，run()方法的实现有两种方式：实现Runnable接口和继承Thread类 4.多个线程并发执行时，各个线程中语句的执行顺序是确定的，但是线程之间的相对执行顺序是不确定的 6.Java中的对象锁是一种独占的排他锁 7.程序中可能出现一种情况：多个线种互相等待对方持有的锁，而在得到对方的锁之前都不会释放自己的锁，这就是死锁 8.线程的优先级是在Thread类的常数MIN_PRIORITY和MAX_PRIORITY 之间的一个值 9.处于新建状态的线程可以使用的控制方法是start()和stop()。 10.一个进程可以包含多个线程
在什么情况下使用线程池？ 1.单个任务处理的时间比较短 2.将需处理的任务的数量大 使用线程池的好处: 1.减少在创建和销毁线程上所花的时间以及系统资源的开销 2.如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。 线程池工作原理：
线程池为线程生命周期开销问题和资源不足问题提供了解决方案。通过对多个任务重用线程，线程创建的开销被分摊到了多个任务上。其好处是，因为在请求到达时线程已经存在，所以无意中也消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使应用程序响应更快。而且，通过适当地调整线程池中的线程数目，也就是当请求的数目超过某个阈值时，就强制其它任何新到的请求一直等待，直到获得一个线程来处理为止，从而可以防止资源不足。 线程池的替代方案 线程池远不是服务器应用程序内使用多线程的唯一方法。如同上面所提到的，有时，为每个新任务生成一个新线程是十分明智的。然而，如果任务创建过于频繁而任务的平均处理时间过短，那么为每个任务生成一个新线程将会导致性能问题。 另一个常见的线程模型是为某一类型的任务分配一个后台线程与任务队列。AWT 和 Swing 就使用这个模型，在这个模型中有一个 GUI 事件线程，导致用户界面发生变化的所有工作都必须在该线程中执行。然而，由于只有一个 AWT 线程，因此要在 AWT 线程中执行任务可能要花费相当长时间才能完成，这是不可取的。因此，Swing 应用程序经常需要额外的工作线程，用于运行时间很长的、同 UI 有关的任务。 每个任务对应一个线程方法和单个后台线程（single-background-thread）方法在某些情形下都工作得非常理想。每个任务一个线程方法在只有少量运行时间很长的任务时工作得十分好。而只要调度可预见性不是很重要，则单个后台线程方法就工作得十分好，如低优先级后台任务就是这种情况。然而，大多数服务器应用程序都是面向处理大量的短期任务或子任务，因此往往希望具有一种能够以低开销有效地处理这些任务的机制以及一些资源管理和定时可预见性的措施。线程池提供了这些优点。 工作队列 就线程池的实际实现方式而言，术语“线程池”有些使人误解，因为线程池“明显的”实现在大多数情形下并不一定产生我们希望的结果。术语“线程池”先于Java 平台出现，因此它可能是较少面向对象方法的产物。然而，该术语仍继续广泛应用着。 虽然我们可以轻易地实现一个线程池类，其中客户机类等待一个可用线程、将任务传递给该线程以便执行、然后在任务完成时将线程归还给池，但这种方法却存在几个潜在的负面影响。例如在池为空时，会发生什么呢？试图向池线程传递任务的调用者都会发现池为空，在调用者等待一个可用的池线程时，它的线程将阻塞。我们之所以要使用后台线程的原因之一常常是为了防止正在提交的线程被阻塞。完全堵住调用者，如在线程池的“明显的”实现的情况，可以杜绝我们试图解决的问题的发生。 我们通常想要的是同一组固定的工作线程相结合的工作队列，它使用 wait() 和
Java多线程同步机制在售票系统的实现 论文导读：多线程技术的思想已经使用了很长的一段时间。但其不支持相同优先级的时间片轮换。多个用户线程在并发运行过程中可能同时访问临界区的内容。在Java中定义了线程同步的概念。关键词：多线程技术,多线程优先级,时间片,同步,临界区引言：多线程技术的思想已经使用了很长的一段时间，它允许CPU处理器时间共享，即很多用户可以共享处理器，每个用户的任务都分配到一段处理器时间。多线程是现代操作系统有别于传统操作系统的重要标志之一，它有别于传统的多进程的概念。所谓线程就是程序中的一个执行流，多线程程序是指一个程序中包含有多个执行流，多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发性的一个基本单位。1．基本概念：1.1线程与进程的主要区别：①同样作为基本的执行单元，线程的划分比进程小。②多进程每个占有独立的内存空间，而多线程共享同一内存空间，通过共享的内存空间来交换信息，切换效率远远高于多进程。③Java线程调度器支持不同优先级线程的抢占方式，但其不支持相同优先级的时间片轮换。④Java运行时系统所在的操作系统（例如：Windows XP）支持时间片的轮换，则线程调度器就支持相同优先级线程的时间片轮换。免费论文参考网。1.2Java 多线程的特点：1.2.1多线程的继承由于Java引入了包的概念，从而使类的继承更加简便，线程的创建就是一个最好的例子。Java多线程的实现有两种办法①通过Thread继承，在下面的研究中，我主要用继承自Thread类来实现Java的多线程技术。②通过Runnable接口。
1.2.2Java多线程的同步技术Java应用程序的多个线程共享同一进程的数据资源，多个用户线程在并发运行过程中可能同时访问临界区的内容，为了程序的正常运行，在Java中定义了线程同步的概念，实现对临界区共享资源的一致性的维护。1.3.3Java多线程的流程控制Java流程控制的方法有Sleep().Interrupt().Wait().Notif().Join()等。1.3.4临界区在一个多线程的程序当中，单独的并发的线程访问代码段中的同一对象，则这个代码段叫做临界区，我们需要用同步的机制对代码段进行保护，避免程序出现不确定的因素。1.3.5同步机制Java中支持线程的同步机制，它由synchronized方法实现，分为同步块和同步方法，在下面的讨论中用synchronized的同步块来解决问题。2.多线程同步机制在车票系统的实现2.1下面就以售票系统中所涉及的问题来讨论Java的多线程同步机制问题，在售票系统中由于很大一部分时间可能有多人在购买车票，所以必须开辟多个线程同时为他们服务，在这里我设有四个售票窗口，则开辟四个线程来为四个窗口服务模拟图如下：窗口 1 窗口2窗口 3 窗口4Thread1Thread2 Thread3Thread4售票窗口模拟图 2.2出错的程序代码如下：class TicketsSystem{public staticvoid main(String[] args){SellThread kt=new SellThread();new Thread(kt).start();new Thread(kt).start();new Thread(kt).start();new Thread(kt).start();}}class SellThreadextends Thread{inttickets=60;public voidrun(){while(true){if(tickets>0){System.out.println(Thread.currentThr ead().getName()+'sellticket '+tickets);tickets--;}}}}在上面的程序中为了
J a v a第七单元练习题 J a v a多线程机制 The latest revision on November 22, 2020
7Java多线程机制 7.1单项选择题 1. 线程调用了sleep（）方法后，该线程将进入（）状态。 A. 可运行状态 B. 运行状态 C. 阻塞状态 D. 终止状态 2. 关于java线程，下面说法错误的是（） A. 线程是以CPU为主体的行为 B. java利用线程使整个系统成为异步 C. 创建线程的方法有两种：实现Runnable接口和继承Thread类 D. 新线程一旦被创建，它将自动开始运行 3. 在java中的线程模型包含（） A. 一个虚拟处理器 B. CPU执行的代码 C. 代码操作的数据 D. 以上都是 4.在java语言中，临界区可以是一个语句块，或者是一个方法，并用（）关键字标识。 A. synchronized B. include C. import D. Thread 5. 线程控制方法中，yield()的作用是（） A. 返回当前线程的引用 B. 使比其低的优先级线程执行 C. 强行终止线程 D. 只让给同优先级线程运行 6. 线程同步中，对象的锁在（）情况下持有线程返回 A. 当synchronized()语句块执行完后 B. 当在synchronized()语句块执行中出现例外（exception）时 C. 当持有锁的线程调用该对象的wait()方法时 D. 以上都是 7. 在以下（）情况下，线程就进入可运行状态 A. 线程调用了sleep()方法时 B. 线程调用了join()方法时 C. 线程调用了yield()方法时 D. 以上都是 8. java用（）机制实现了进程之间的异步执行
Thread Synchronization https://www.doczj.com/doc/3712793953.html,/insidejvm/ed2/threadsynch.html One of the strengths of the Java programming language is its support for multithreading at the language level. Much of this support centers on synchronization: coordinating activities and data access among multiple threads. The mechanism that Java uses to support synchronization is the monitor. This chapter describes monitors and shows how they are used by the Java virtual machine. It describes how one aspect of monitors, the locking and unlocking of data, is supported in the instruction set. Monitors Java's monitor supports two kinds of thread synchronization: mutual exclusion and cooperation. Mutual exclusion, which is supported in the Java virtual machine via object locks, enables multiple threads to independently work on shared data without interfering with each other. Cooperation, which is supported in the Java virtual machine via the wait and notify methods of class Object, enables threads to work together towards a common goal. A monitor is like a building that contains one special room that can be occupied by only one thread at a time. The room usually contains some data. From the time a thread enters this room to the time it leaves, it has exclusive access to any data in the room. Entering the monitor building is called "entering the monitor." Entering the special room inside the building is called "acquiring the monitor." Occupying the room is called "owning the monitor," and leaving the room is called "releasing the monitor." Leaving the entire building is called "exiting the monitor." In addition to being associated with a bit of data, a monitor is associated with one or more bits of code, which in this book will be called monitor regions. A monitor region is code that needs to be executed as one indivisible operation with respect to a particular monitor. In other words, one thread must be able to execute a monitor region from beginning to end without another thread concurrently executing a monitor region of the same monitor. A monitor enforces this one-thread-at-a-time execution of its monitor regions. The only way a thread can enter a monitor is by arriving at the beginning of one of the monitor regions associated with that monitor. The only way a thread can move forward and execute the monitor region is by acquiring the monitor. When a thread arrives at the beginning of a monitor region, it is placed into an entry set for the associated monitor. The entry set is like the front hallway of the monitor building. If no other thread is waiting in the entry set and no other thread
Timer计时器有管理任务延迟执行("如1000ms后执行任务")以及周期性执行("如每500ms执行一次该任务")。但是，Timer存在一些缺陷，因此你应该考虑使用ScheduledThreadPoolExecutor作为代替品,Timer对调度的支持是基于绝对时间,而不是相对时间的，由此任务对系统时钟的改变是敏感的;ScheduledThreadExecutor只支持相对时间。 Timer的另一个问题在于，如果TimerTask抛出未检查的异常，Timer将会产生无法预料的行为。Timer线程并不捕获异常，所以TimerTask抛出的未检查的异常会终止timer 线程。这种情况下，Timer也不会再重新恢复线程的执行了;它错误的认为整个Timer都被取消了。此时，已经被安排但尚未执行的TimerTask永远不会再执行了，新的任务也不能被调度了。 例子： packagecom.concurrent.basic; importjava.util.Timer; import java.util.TimerTask; public class TimerTest { private Timer timer = new Timer(); // 启动计时器 public void lanuchTimer() { timer.schedule(new TimerTask() { public void run() { throw new RuntimeException(); } }, 1000 * 3, 500); } // 向计时器添加一个任务 public void addOneTask() { timer.schedule(new TimerTask() { public void run() { System.out.println("hello world"); } }, 1000 * 1, 1000 * 5); }
Java多线程50题 1)什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。 2)线程和进程有什么区别？ 线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据。更多详细信息请点击这里。 3)如何在Java中实现线程？ https://www.doczj.com/doc/3712793953.html,ng.Thread类的实例就是一个线程但是它需要调用https://www.doczj.com/doc/3712793953.html,ng.Runnable接口来执行，由于线程类本身就是调用的 Runnable接口所以你可以继承https://www.doczj.com/doc/3712793953.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()调用之 后，也叫作线程启动规则。 ●一个线程的所有操作都会在线程终止之前，线程终止规
1、当多个线程共享某个资源时，为了确保在任何时间点一个共享资源只被一个线程使用，避免造成数据的不一致，需要使用线程同步机制，线程同步有几种方式？分别如何实现? 答:有两种方式: 第一种方式:使用同步方法 synchronized void methodA(){} 第二种方式:使用同步代码块 void methodA(){ synchronized{ } } 2、以下是一个模拟订票业务的程序。BookingClerk类代表自动售票员，其中包含一个订票（booking）方法。假设一开始有10张票可预定。程序运行时产生两个订票客户同时自动向自动售票员订票。请问会出现什么错误？该如何修改？ (考点：临界区与互斥) public class Test { public static void main(String args[]) { BookingClerk bt = new BookingClerk(); new BookingTest(bt, 7); new BookingTest(bt, 5); } } class BookingClerk { int remainder = 10; void booking(int num) { if (num <= remainder) { System.out.println("预定" + num + "张票"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } remainder = remainder - num; } else { System.out.println("剩余票不够，无法预定"); } System.out.println("还剩"+remainder+"张票"); } } class BookingTest implements Runnable {
废话不多说开整 我用的是eclipse（这应该没多大影响） 建一个工程java工程和web工程都行然后建一个包建一个类带main方法 首先贴出来的是内部类 //继承了runnable接口 class MyTask implements Runnable { private int taskNum; public MyTask(int num) { this.taskNum = num; } @Override public void run() { System.out.println("正在执行task "+taskNum); try { //写业务 Thread.currentThread().sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("task "+taskNum+"执行完毕！"); } } 接下来就是这个类 public class testOne { public static void main(String[] args) { ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 7, 10, https://www.doczj.com/doc/3712793953.html,LISECONDS, new ArrayBlockingQueue
for(int i=0;i<15;i++){ MyTask myTask = new MyTask(i); executor.execute(myTask); System.out.println("线程池中线程数目： "+executor.getPoolSize()+"队列等待执行的任务数目："+ executor.getQueue().size()+"已经执行完别的任务数目： "+executor.getCompletedTaskCount()); } executor.shutdown(); } } 接下来在说明一下ThreadPoolExecutor的参数设置ThreadPoolExecutor(int corePoolSize,//线程池维护线程的最少数量 int maximumPoolSize,//线程池维护线程的最大数量 long keepAliveTime,//线程池维护线程所允许的空闲时间 TimeUnit unit, 线程池维护线程所允许的空闲时间单位 BlockingQueue workQueue,线程池所使用的缓存队列 RejectedExecutionHandler handler线程池对拒绝任务的处理策略 ) handler有四个选择： ThreadPoolExecutor.AbortPolicy() 抛出java.util.concurrent.RejectedExecutionException异常 ThreadPoolExecutor.CallerRunsPolicy() 重试添加当前的任务，他会自动重复调用execute()方法 ThreadPoolExecutor.DiscardOldestPolicy() 抛弃旧的任务 ThreadPoolExecutor.DiscardPolicy() 抛弃当前的任务 上面是一个例子接下来再来一个例子
深入研究线程池 一.什么是线程池? 线程池就是以一个或多个线程[循环执行]多个应用逻辑的线程集合. 注意这里用了线程集合的概念是我生造的,目的是为了区分执行一批应用逻辑的多个线程和 线程组的区别.关于线程组的概念请参阅基础部分. 一般而言,线程池有以下几个部分: 1.完成主要任务的一个或多个线程. 2.用于调度管理的管理线程. 3.要求执行的任务队列. 那么如果一个线程循环执行一段代码是否是线程池? 如果极端而言,应该算,但实际上循环代码应该算上一个逻辑单元.我们说最最弱化的线程池 应该是循环执行多个逻辑单元.也就是有一批要执行的任务,这些任务被独立为多个不同的执行单元.比如: int x = 0; while(true){ x ++; } 这就不能说循环中执行多个逻辑单元,因为它只是简单地对循环外部的初始变量执行++操作. 而如果已经有一个队列 ArrayList al = new ArrayList(); for(int i=0;i<10000;i++){ al.add(new AClass()); } 然后在一个线程中执行: while(al.size() != 0){ AClass a = (AClass)al.remove(0); a.businessMethod(); } 我们说这个线程就是循环执行多个逻辑单元.可以说这个线程是弱化的线程池.我们习惯上把这些相对独立的逻辑单元称为任务. 二.为什么要创建线程池? 线程池属于对象池.所有对象池都具有一个非常重要的共性,就是为了最大程度复用对象.那么 线程池的最重要的特征也就是最大程度利用线程. 从编程模型模型上说讲,在处理多任务时,每个任务一个线程是非常好的模型.如果确实可以这么做我们将可以使用编程模型更清楚,更优化.但是在实际应用中,每个任务一个线程会使用系统限入"过度切换"和"过度开销"的泥潭. 打个比方,如果可能,生活中每个人一辆房车,上面有休息,娱乐,餐饮等生活措施.而且道路交道永远不堵车,那是多么美好的梦中王国啊.可是残酷的现实告诉我们,那是不可能的.不仅每个人一辆车需要无数多的社会资源,而且地球上所能容纳的车辆总数是有限制的. 首先,创建线程本身需要额外(相对于执行任务而必须的资源)的开销.
7 Java 多线程机制 7.1 单项选择题 1. 线程调用了sleep ()方法后，该线程将进入( )状态。 A. 可运行状态 B. 运行状态 C. 阻塞状态 D. 终止状态 2. 关于java 线程，下面说法错误的是() A. 线程是以CPU为主体的行为 B. java 利用线程使整个系统成为异步 C. 创建线程的方法有两种：实现Runnable 接口和继承Thread 类 D. 新线程一旦被创建，它将自动开始运行 3. 在java 中的线程模型包含() A. 一个虚拟处理器 B. CPU执行的代码 C. 代码操作的数据 D. 以上都是 4. 在java 语言中，临界区可以是一个语句块，或者是一个方法，并用()关键字标识。 A. synchronized B. include C. import D. Thread 5. 线程控制方法中，yield()的作用是() A. 返回当前线程的引用 B. 使比其低的优先级线程执行 C. 强行终止线程 D. 只让给同优先级线程运行 6. 线程同步中，对象的锁在()情况下持有线程返回 A. 当synchronized()语句块执行完后 B. 当在synchronized()语句块执行中出现例外( exception )时 C. 当持有锁的线程调用该对象的wait()方法时 D. 以上都是 7. 在以下()情况下，线程就进入可运行状态 A. 线程调用了sleep()方法时 B. 线程调用了join()方法时 C. 线程调用了yield()方法时 D. 以上都是 8. java 用()机制实现了进程之间的异步执行 A. 监视器 B. 虚拟机
一、引言 前几天面试，被大师虐残了，好多基础知识必须得重新拿起来啊。闲话不多说，进入正题。 二、为什么要线程同步 因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取100块，一个存钱100块。假设账户原本有0块，如果取钱线程和存钱线程同时发生，会出现什么结果呢？取钱不成功，账户余额是100.取钱成功了，账户余额是0.那到底是哪个呢？很难说清楚。因此多线程同步就是要解决这个问题。 三、不同步时的代码 Bank.java 1.packagethreadTest; 2. 3./** 4.*@authorww 5.* 6.*/ 7.publicclassBank{ 8. 9.privateintcount=0;//账户余额 10. 11.//存钱 12.publicvoidaddMoney(intmoney){ 13.count+=money; 14.System.out.println(System.currentTimeMillis()+"存进："+money); 15.} 16. 17.//取钱 18.publicvoidsubMoney(intmoney){ 19.if(count-money<0){ 20.System.out.println("余额不足"); 21.return; 22.} 23.count-=money; 24.System.out.println(+System.currentTimeMillis()+"取出："+money); 25.} 26. 27.//查询
java线程同步与异步线程池 java线程同步与异步线程池 1）多线程并发时，多个线程同时请求同一个资源，必然导致此资源的数据不安全，A线程修改了B线 程的处理的数据，而B线程又修改了A线程处理的数理。显然这是由于全局资源造成的，有时为了解 决此问题，优先考虑使用局部变量，退而求其次使用同步代码块，出于这样的安全考虑就必须牺牲 系统处理性能，加在多线程并发时资源挣夺最激烈的地方，这就实现了线程的同步机制同步：A线程要请求某个资源，但是此资源正在被B线程使用中，因为同步机制存在，A线程请求 不到，怎么办，A线程只能等待下去 异步：A线程要请求某个资源，但是此资源正在被B线程使用中，因为没有同步机制存在，A线程 仍然请求的到，A线程无需等待
显然，同步最最安全，最保险的。而异步不安全，容易导致死锁，这样一个线程死掉就会导致整个 进程崩溃，但没有同步机制的存在，性能会有所提升 java中实现多线程 1）继承Thread,重写里面的run方法 2）实现runnable接口 Doug Lea比较推荐后者，第一，java没有单继承的限制第二，还可以隔离代码 线程池 要知道在计算机中任何资源的创建，包括线程，都需要消耗系统资源的。在WEB服务中，对于web服 务器的响应速度必须要尽可能的快，这就容不得每次在用户提交请求按钮后，再创建线程提供服务 。为了减少用户的等待时间，线程必须预先创建，放在线程池中，线程池可以用HashTable这种数
据结构来实现，看了Apach HTTP服务器的线程池的源代码，用是就是HashTable,KEY 用线程对象， value用ControlRunnable，ControlRunnable是线程池中唯一能干活的线程，是它指派线程池中的 线程对外提供服务。 出于安全考虑，Apach HTTP服务器的线程池它是同步的。听说weblogic有异步的实现方式，没有研 究过，不敢确定 --------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------一、关键字： thread（线程）、thread-safe(线程安全)、intercurrent（并发的） synchronized(同步的)、asynchronized(异步的)、 volatile（易变的）、atomic（原子的）、share（共享） 二、总结背景： 一次读写共享文件编写，嚯，好家伙，竟然揪出这些零碎而又是一路的知识点。于是乎，
Tomcat线程池实现简介 目前市场上常用的开源Java Web容器有Tomcat、Resin和Jetty。其中Resin从V3.0后需要购买才能用于商业目的，而其他两种则是纯开源的。可以分别从他们的网站上下载最新的二进制包和源代码。 作为Web容器，需要承受较高的访问量，能够同时响应不同用户的请求，能够在恶劣环境下保持较高的稳定性和健壮性。在HTTP服务器领域，Apache HTTPD的效率是最高的，也是最为稳定的，但它只能处理静态页面的请求，如果需要支持动态页面请求，则必须安装相应的插件，比如mod_perl可以处理Perl脚本，mod_python可以处理Python脚本。 上面介绍的三中Web容器，都是使用Java编写的HTTP服务器，当然他们都可以嵌到Apache 中使用，也可以独立使用。分析它们处理客户请求的方法有助于了解Java多线程和线程池的实现方法，为设计强大的多线程服务器打好基础。 Tomcat是使用最广的Java Web容器，功能强大，可扩展性强。最新版本的Tomcat（5.5.17）为了提高响应速度和效率，使用了Apache Portable Runtime（APR）作为最底层，使用了APR 中包含Socket、缓冲池等多种技术，性能也提高了。APR也是Apache HTTPD的最底层。可想而知，同属于ASF（Apache Software Foundation）中的成员，互补互用的情况还是很多的，虽然使用了不同的开发语言。 Tomcat 的线程池位于tomcat-util.jar文件中，包含了两种线程池方案。方案一：使用APR 的Pool技术，使用了JNI；方案二：使用Java实现的ThreadPool。这里介绍的是第二种。如果想了解APR的Pool技术，可以查看APR的源代码。 ThreadPool默认创建了5个线程，保存在一个200维的线程数组中，创建时就启动了这些线程，当然在没有请求时，它们都处理“等待”状态（其实就是一个while循环，不停的等待notify）。如果有请求时，空闲线程会被唤醒执行用户的请求。 具体的请求过程是：服务启动时，创建一个一维线程数组（maxThread＝200个），并创建空闲线程(minSpareThreads＝5个)随时等待用户请求。当有用户请求时，调用threadpool.runIt(ThreadPoolRunnable)方法，将一个需要执行的实例传给ThreadPool中。其中用户需要执行的实例必须实现ThreadPoolRunnable接口。ThreadPool 首先查找空闲的线程，如果有则用它运行要执行ThreadPoolRunnable；如果没有空闲线程并且没有超过maxThreads，就一次性创建minSpareThreads个空闲线程；如果已经超过了maxThreads了，就等待空闲线程了。总之，要找到空闲的线程，以便用它执行实例。找到后，将该线程从线程数组中移走。接着唤醒已经找到的空闲线程，用它运行执行实例（ThreadPoolRunnable）。运行完ThreadPoolRunnable后，就将该线程重新放到线程数组中，作为空闲线程供后续使用。 由此可以看出，Tomcat的线程池实现是比较简单的，ThreadPool.java也只有840行代码。用一个一维数组保存空闲的线程，每次以一个较小步伐（5个）创建空闲线程并放到线程池中。使用时从数组中移走空闲的线程，用完后，再“归还”给线程池。ThreadPool提供的仅仅是线程池的实现，而如何使用线程池也是有很大学问的。让我们看看Tomcat是如何使用ThreadPool的吧。 Tomcat有两种EndPoint，分别是AprEndpoint和PoolTcpEndpoint。前者自己实现了一套线