java教材源代码第10章 线程

第9章线程

【例9-1】利用Thread类创建线程。

public class ThreadTest extends Thread {

String threadName;

public ThreadTest(String s) {

System.out.println(" Making thread:" + s );

threadName=s;

}

public void run() {

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

System.out.println(" Running thread number=" + threadName);

try {

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

}

catch ( InterruptedException ex ) {

System.err.println(ex.toString());

}

}

}

public static void main(String[] args) {

ThreadTest thread1 = new ThreadTest("Tom");

ThreadTest thread2 = new ThreadTest("Jack");

thread1.start();

thread2.start();

System.out.println("End of main");

}

}

4.线程实例

下面是一个Race类，它模拟兔子和乌龟之间的赛跑。用Math.random()方法使比赛更激烈。

import java.awt.*;

import https://www.wendangku.net/doc/433509120.html,ng.Math;

import https://www.wendangku.net/doc/433509120.html,ng.Thread;

public class Race

{

public static void main (String args [])

{ Animat rabbit = new Animat("Rabbit", 15 , 50);

Animat turtle = new Animat("Turtle", 12 , 50);

Thread myThread1 = new Thread (rabbit);

Thread myThread2 = new Thread (turtle);

myThread1.start();

myThread2.start();

System.out.println("This is the main application.");

}

}

class Animat implements Runnable

{

private String name;

private int speed;

private int distance;

private int curdistance = 0;

public Animat (String name, int speed, int distance)

{

https://www.wendangku.net/doc/433509120.html, = name;

this.speed = speed;

this.distance = distance;

}

public void run()

{

while ( curdistance < distance )

{

try

{ Thread.sleep ( (int) (Math.random() * 1000) + 500 );

}

catch (Exception e) {}

curdistance += Math.random () * speed ;

System.out.println (name + " : I am at " + curdistance ); }

System.out.println (name + " have finished ! ");

}

}

【例9-2】利用Runnable接口创建线程。

public class RunnableTest implements Runnable {

String threadName;

public RunnableTest (String s) {

System.out.println(" Making thread:" + s);

threadName=s;

}

public void run() {

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

System.out.println(" Running thread number=" + threadName); try {

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

}catch ( InterruptedException ex ) {

System.err.println(ex.toString());

}

}

}

public static void main(String[] args) {

Thread thread1,thread2;

// 创建线程

thread1 = new Thread( new RunnableTest("Tom") );

thread2 = new Thread( new RunnableTest("Jack") );

// 启动线程

thread1.start();

thread2.start();

System.out.println("End of main");

}

}

【例9-3】sleep()方法的使用。

import java.math.*;

class ThreadTest{

public static void main(String agrs[]){

//创建线程

PrintThread thread1=new PrintThread("thread1");

PrintThread thread2=new PrintThread("thread2");

PrintThread thread3=new PrintThread("thread3");

System.out.println("Starting threads");

thread1.start();

thread2.start();

thread3.start();

System.out.println("Threads started, main thread ends\n");

}

}

public class PrintThread extends Thread {

private int sleepTime;

public PrintThread(String name){

super(name);

sleepTime=(int)(Math.random() *5001);

}

public void run(){

try{

System.err.println(getName()+"going to sleep for "+sleepTime);

Thread.sleep(sleepTime);

}catch(InterruptedException exception){

exception.printStackTrace();

}

System.err.println(getName()+"done sleeping");

}

}

【例9-4】join()方法的使用。

class Counter extends Thread {

private int currentValue;

public Counter(String threadName) {

super(threadName);

currentValue = 0;

System.out.println(this);

//System.out.println(Thread.currentThread());

setPriority(10);

start();

}

public void run() {

try {

while (currentValue < 5) {

System.out.println(getName() + ": " +(currentValue++));

Thread.sleep(500);

}

} catch (InterruptedException e) {

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

}

System.out.println("Exit from " + getName() + ".");

}

public int getValue() {

return currentValue;

}

}

public class ThreadJoinAndIsAlive {

public static void main(String args[]) {

Counter cA = new Counter("Counter A");

Counter cB = new Counter("Counter B");

System.out.println("!!!!!!!" + cB.getPriority());

try {

System.out.println("Wait for the child threads to finish."); cA.join();

System.out.println(" Current thread is: " +

Thread.currentThread().getName()+ " Its Priority is: " +

Thread.currentThread().getPriority());

System.out.println(" I am here 111");

//cB.join();

if (!cA.isAlive())

System.out.println("Counter A not alive.");

if (!cB.isAlive())

System.out.println("Counter B not alive.");

} catch (InterruptedException e) {

System.out.println("Main Thread interrupted.");

}

System.out.println("Exit from Main Thread.");

}

}

【例9-5】线程应用的综合例子。

class SimpleRunnable implements Runnable {

//一个实现Runnable接口的SimpleRunnable类。

protected String message;

protected int iterations;

public SimpleRunnable(String msg, int iter) {

message = msg;

iterations = iter;

}

public void run() {

for (int i=0; i

System.out.println(message);

try {

Thread.sleep(100);

} catch (InterruptedException e) {

System.out.println(e);

}

}

}

}

//ThreadExample类运行这个线程。

public class ThreadExample {

public static void main(String args[]) {

Thread t1, t2;

t1 = new Thread(new SimpleRunnable("Thread 1", 10));

t2 = new Thread(new SimpleRunnable("Thread 2", 15));

System.out.println("T1 p is: " + t1.getPriority());

System.out.println("T2 p is: " + t2.getPriority());

t2.setPriority(7);

System.out.println("T2 after set p is: " + t2.getPriority());

t2.yield();

System.out.println("T2 after yield p is: " + t2.getPriority());

t1.start();

t2.start();

}

}

【例9-6】主线程的使用。

class CurrentThreadDemo{

public static void main(String args[]) {

Thread t=Thread.currentThread();

System.out.println("Current thread : "+t);

// 改变线程的名称

t.setName("My Thread");

System.out.println("After name change: "+t);

try{

for (int n=5; n>0; n--){

System.out.println(n);

Thread.sleep(1000);

}

}catch (InterruptedException e){

System.out.println("Main thread interrupted ");

}

}

}

【例9-7】用synchronized关键字实现代码段同步的示例。

public class BookShelf {

String bookName;

int amount;

public BookShelf (String name, int amt) {

bookName = name;

amount = amt;

}

public synchronized void putIn(int amt) {

amount += amt;

}

public synchronized void withdraw(int amt) {

amount -= amt;

}

public int checkRemainder () {

return amount;

}

}

【例9-8】使用wait()与notify()方法。

public class WaitTest {

public static void main(String [] args) {

ThreadB b = new ThreadB();

b.start();

System.out.println("Total b is: " + b.getTotal());

}

}

class ThreadB extends Thread {

int total;

public void run() {

synchronized(this) {

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

total += i;

}

System.out.println("In ThreadB total is: " + total); notify();

}

}

synchronized public int getTotal() {

try{

wait();

}catch(InterruptedException e) {}

return total;

}

}

【例9-9】使用wait()与notify()方法协调线程对共享队列中的数据进行读写访问。

public class Queue {//共享数据结构——队列

protected Object[] data;

protected int writeIndex;

protected int readIndex;

protected int count;

public Queue(int size) {

data = new Object[size];

}

public synchronized void write(Object value) {//同步对共享数据的写操作 while(count >= data.length) {

try{

wait(); //阻塞，等待共享数据的同步读操作唤醒

}catch(InterruptedException e) {}

}

data[writeIndex++] = value;

System.out.println("write data is: " + value);

writeIndex %= data.length;

count += 1;

notify(); //唤醒处于阻塞状态的同步读操作

}

public synchronized void read() {//同步对共享数据的读操作

while(count <= 0){

try{

wait(); //阻塞，等待共享数据的同步写操作唤醒

}catch(InterruptedException e) {}

}

Object value = data[readIndex++];

System.out.println("read data is: " + value);

readIndex %= data.length;

count =－1;

notify(); //唤醒处于阻塞状态的同步读操作

}

public static void main(String[] args) {

Queue q = new Queue(5);

new Writer(q); //实例化并启动写线程

new Reader(q); //实例化并启动读线程

}

class Writer implements Runnable{//写线程

Queue queue;

Writer(Queue target){

queue = target;

new Thread(this).start();

}

public void run(){//线程体

int i = 0;

while(i<5){

queue.write(new Integer(i));

i++;

}

}

}

class Reader implements Runnable{//读线程 Queue queue;

Reader(Queue source){

queue = source;

new Thread(this).start();

}

public void run(){//线程体

int i=0;

while(i<5){

queue.read();

}

}

}

【例9-10】Java线程同步出现死锁。

Public class DeadlockRisk{

Private static class Resource{

Public int value;

}

private Resource resourceA-new Resource(); private Resource resourceB-new Resource(); public int read(){

synchronized(resourceA) {//这里出现死锁sysnchronized(resourceB){

return resourceB.value+resourceA.value;}

}

public void write(int a, int b){

synchronized(resourceB){//这里出现死锁 synchronized(resourceA){

resourceA.value-a;

resourceB.value-b;}

}

}

}

Java多线程技术及案例

Java多线程技术及案例 进程和线程： 进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1–n个线程。 线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。 线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。 多进程是指操作系统能同时运行多个任务（程序）。 多线程是指在同一程序中有多个顺序流在执行。 Java中多线程的多种实现方式 Java中有多种多线程实现方法，主要是继承https://www.wendangku.net/doc/433509120.html,ng.Thread类的方法和 https://www.wendangku.net/doc/433509120.html,ng.Runnable接口的方法。 继承Thread类 Thread是https://www.wendangku.net/doc/433509120.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线程池原理333

在什么情况下使用线程池？ 1.单个任务处理的时间比较短 2.将需处理的任务的数量大 使用线程池的好处: 1.减少在创建和销毁线程上所花的时间以及系统资源的开销 2.如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。 线程池工作原理：

线程池为线程生命周期开销问题和资源不足问题提供了解决方案。通过对多个任务重用线程，线程创建的开销被分摊到了多个任务上。其好处是，因为在请求到达时线程已经存在，所以无意中也消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使应用程序响应更快。而且，通过适当地调整线程池中的线程数目，也就是当请求的数目超过某个阈值时，就强制其它任何新到的请求一直等待，直到获得一个线程来处理为止，从而可以防止资源不足。 线程池的替代方案 线程池远不是服务器应用程序内使用多线程的唯一方法。如同上面所提到的，有时，为每个新任务生成一个新线程是十分明智的。然而，如果任务创建过于频繁而任务的平均处理时间过短，那么为每个任务生成一个新线程将会导致性能问题。 另一个常见的线程模型是为某一类型的任务分配一个后台线程与任务队列。AWT 和 Swing 就使用这个模型，在这个模型中有一个 GUI 事件线程，导致用户界面发生变化的所有工作都必须在该线程中执行。然而，由于只有一个 AWT 线程，因此要在 AWT 线程中执行任务可能要花费相当长时间才能完成，这是不可取的。因此，Swing 应用程序经常需要额外的工作线程，用于运行时间很长的、同 UI 有关的任务。 每个任务对应一个线程方法和单个后台线程（single-background-thread）方法在某些情形下都工作得非常理想。每个任务一个线程方法在只有少量运行时间很长的任务时工作得十分好。而只要调度可预见性不是很重要，则单个后台线程方法就工作得十分好，如低优先级后台任务就是这种情况。然而，大多数服务器应用程序都是面向处理大量的短期任务或子任务，因此往往希望具有一种能够以低开销有效地处理这些任务的机制以及一些资源管理和定时可预见性的措施。线程池提供了这些优点。 工作队列 就线程池的实际实现方式而言，术语“线程池”有些使人误解，因为线程池“明显的”实现在大多数情形下并不一定产生我们希望的结果。术语“线程池”先于Java 平台出现，因此它可能是较少面向对象方法的产物。然而，该术语仍继续广泛应用着。 虽然我们可以轻易地实现一个线程池类，其中客户机类等待一个可用线程、将任务传递给该线程以便执行、然后在任务完成时将线程归还给池，但这种方法却存在几个潜在的负面影响。例如在池为空时，会发生什么呢？试图向池线程传递任务的调用者都会发现池为空，在调用者等待一个可用的池线程时，它的线程将阻塞。我们之所以要使用后台线程的原因之一常常是为了防止正在提交的线程被阻塞。完全堵住调用者，如在线程池的“明显的”实现的情况，可以杜绝我们试图解决的问题的发生。 我们通常想要的是同一组固定的工作线程相结合的工作队列，它使用 wait() 和

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.wendangku.net/doc/433509120.html,ng 包中定义了Runnable 接口和Thread 类。

Java第七单元练习题-Java多线程机制

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.进程是由代码、数据、内核状态和一组寄存器组成，而线程是表示程序运行状态的

java多线程实现调度

重庆交通大学综合性设计性实验报告 实验项目名称：进程调度（先来先服务） 实验项目性质： 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.*;

Java第七单元练习题Java多线程机制

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用（）机制实现了进程之间的异步执行

手把手教你做一个java线程池小例子

废话不多说开整 我用的是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.wendangku.net/doc/433509120.html,LISECONDS, new ArrayBlockingQueue(2),new ThreadPoolExecutor.DiscardOldestPolicy() );

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() 抛弃当前的任务 上面是一个例子接下来再来一个例子

java深入理解线程池

深入研究线程池 一.什么是线程池? 线程池就是以一个或多个线程[循环执行]多个应用逻辑的线程集合. 注意这里用了线程集合的概念是我生造的,目的是为了区分执行一批应用逻辑的多个线程和 线程组的区别.关于线程组的概念请参阅基础部分. 一般而言,线程池有以下几个部分: 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(); } 我们说这个线程就是循环执行多个逻辑单元.可以说这个线程是弱化的线程池.我们习惯上把这些相对独立的逻辑单元称为任务. 二.为什么要创建线程池? 线程池属于对象池.所有对象池都具有一个非常重要的共性,就是为了最大程度复用对象.那么 线程池的最重要的特征也就是最大程度利用线程. 从编程模型模型上说讲,在处理多任务时,每个任务一个线程是非常好的模型.如果确实可以这么做我们将可以使用编程模型更清楚,更优化.但是在实际应用中,每个任务一个线程会使用系统限入"过度切换"和"过度开销"的泥潭. 打个比方,如果可能,生活中每个人一辆房车,上面有休息,娱乐,餐饮等生活措施.而且道路交道永远不堵车,那是多么美好的梦中王国啊.可是残酷的现实告诉我们,那是不可能的.不仅每个人一辆车需要无数多的社会资源,而且地球上所能容纳的车辆总数是有限制的. 首先,创建线程本身需要额外(相对于执行任务而必须的资源)的开销.

Java多线程和网络编程项目

Megan package MultiTCP; import java.io.DataOutputStream; import java.io.IOException; import https://www.wendangku.net/doc/433509120.html,.ServerSocket; import https://www.wendangku.net/doc/433509120.html,.Socket; /** * 必须先启动再连接 * 1、创建服务器指定端口ServerSocket(int port) * 2、接收客户端的连接阻塞式 * 3、发送数据+接收数据 * * 接收多个客户端 */ @SuppressWarnings("all") public class MultiServer { public static void main(String[] args) throws IOException { //1、创建服务器指定端口 ServerSocket server = new ServerSocket(8888); while(true)//死循环一个accept 一个客户端 { //2、接收客户端的连接 Socket socket = server.accept(); System.out.println("一个客户端建立连接"); //2、发送数据 String msg = "欢迎使用"; //3、输出流 /*BufferedWriter bw = new BufferedWriter( new OutputStreamWriter( socket.getOutputStream())); bw.write(msg); bw.newLine();//一定要加行结束符，不然读不到数据 bw.flush();*/ DataOutputStream dos = new DataOutputStream(socket.getOutputStream()); dos.writeUTF(msg); dos.flush(); } } } package MultiTCP; import java.io.DataInputStream;

java多线程并发面试题【java多线程和并发基础面试题】

java多线程并发面试题【java多线程和并 发基础面试题】 多线程和并发问题是Java技术面试中面试官比较喜欢问的问题之一。下面就由小编为大家介绍一下java多线程和并发基础面试题的文章，欢迎阅读。 java多线程和并发基础面试题篇1 1. 进程和线程之间有什么不同? 一个进程是一个独立(self contained)的运行环境，它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的来创建和驻留在进程中，并且可以共享进程中的。 2. 多线程编程的好处是什么? 在多线程程序中，多个线程被并发的执行以提高程序的效率，CPU不会因为某个线程需要等待而进入空闲状态。多个线程共享堆内存(heap memory)，因此创建多个线程去执行一些任务会比创建多个进程更好。举个例子，Servlets比CGI更好，是因为Servlets支持多线程而CGI不支持。 3. 用户线程和守护线程有什么区别? 当我们在Java程序中创建一个线程，它就被称为用户线程。一个守护线程是在后台执行并且不会阻止JVM终止的

线程。当没有用户线程在运行的时候，JVM关闭程序并且退出。一个守护线程创建的子线程依然是守护线程。 4. 我们如何创建一个线程? 有两种创建线程的方法：一是实现Runnable接口，然后将它传递给Thread的构造函数，创建一个Thread对象;二是直接继承Thread类。 java多线程和并发基础面试题篇2 1. 有哪些不同的线程生命周期? 当我们在Java程序中新建一个线程时，它的状态是New。当我们调用线程的start()方法时，状态被改变为Runnable。线程调度器会为Runnable线程池中的线程分配CPU时间并且讲它们的状态改变为Running。其他的线程状态还有Waiting，Blocked 和Dead。 2. 可以直接调用Thread类的run()方法么? 当然可以，但是如果我们调用了Thread的run()方法，它的行为就会和普通的方法一样，为了在新的线程中执行我们的代码，必须使用Thread.start()方法。 3. 如何让正在运行的线程暂停一段时间? 我们可以使用Thread类的Sleep()方法让线程暂停一段时间。需要注意的是，这并不会让线程终止，一旦从休眠中唤醒线程，线程的状态将会被改变为Runnable，并且根据线程调度，它将得到执行。

JAVA多线程(一)基本概念和上下文切换性能损耗

JAVA多线程（一）基本概念和上下文切换性能损耗 1 多线程概念 在理解多线程之前，我们先搞清楚什么是线程。根据维基百科的描述，线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是行程中的实际运行单位。一条线程指的是进程中一个单一顺序的控制流，一個进程中可以并行多个线程，每条线程并行执行不同的任务。每个线程共享堆空间，拥有自己独立的栈空间。 这里反复出现的概念是线程和进程，我们在这里列出它们的区别： 线程划分尺度小于进程，线程隶属于某个进程； 进程是CPU、内存等资源占用的基本单位，线程是不能独立占有这些资源的； 进程之间相互独立，通信比较困难，而线程之间共享一块内存区域，通信方便； 进程在执行过程中，包含比较固定的入口、执行顺序和出口，而进程的这些过程会被应用程序控制。 多线程是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时

间执行多个线程，进而提升整体处理效能。 2 为什么要使用多线程 随着计算机硬件的发展，多核CPU已经屡见不鲜了，甚至手机处理器都早已是多核的天下。这就给我们使用多线程提供了硬件基础，但是，只是因为硬件让我们可以实现多线程，就要这样做吗？一起来看看多线程的优点： 更高的运行效率。在多核CPU上，线程之间是互相独立的，不用互相等待，也就是所谓的“并行“。举个例子，一个使用多线程的文件系统可以实现高吞吐量和低延迟。这是因为我们可以用一个线程来检索存储在高速介质（例如高速缓冲存储器）中的数据，另一个线程检索低速介质（例如外部存储）中的数据，二者互不干扰，也不用等到另一个线程结束才执行； 多线程是模块化的编程模型。在单线程中，如果主执行线程在一个耗时较长的任务上卡住，或者因为网络响应问题陷入长时间等待，此时程序不会响应鼠标和键盘等操作。多线程通过将程序分成几个功能相对独立的模块，单独分配一个线程去执行这个长耗时任务，不影响其它线程的执行，就可以避免这个问题； 与进程相比，线程的创建和切换开销更小。使用多线程为多个客户端服务，比使用多进程消耗的资源少得多。由于启动

运用JAVA的concurrent.ExecutorService线程池实现socket的TCP和UDP连接

运用JAVA的concurrent.ExecutorService线程池实现socket的TCP和UDP连接 最近在项目中可能要用到socket相关的东西来发送消息，所以初步研究了下socket 的TCP和UDP实现方式，并且结合java1.5的concurrent.ExecutorService类来实现多线程。 具体实现方式见代码： 一、TCP方式： 1、服务端实现方式： TCP的服务端实现方式主要用到ServerSocket类，接收等待客户端连接的方法是accept(); 代码如下：类SocketServerTCP 1private int port=8823; 2private ServerSocket serverSocket; 3private ExecutorService executorService;//线程池 4private final int POOL_SIZE=100;//单个CPU线程池大小 5 6public SocketServerTCP(){ 7try{ 8serverSocket=new ServerSocket(port); 9executorService= Executors.newFixedThreadPool(Runtime.getRuntime() 10.availableProcessors()*POOL_SIZE); https://www.wendangku.net/doc/433509120.html,("端口号为"+port+"的服务器启动"); 12}catch(IOException e){ 13 e.printStackTrace(); 14} 15} 16 17public void service(){ 18System.out.println("socket初始化成功！"); https://www.wendangku.net/doc/433509120.html,("socket服务端初始化成功！"); 20while(true){ 21Socket socket=null; 22try{ 23//接收客户连接,只要客户进行了连接,就会触发accept();从而建立连接

java线程池_2

线程池的作用: 线程池作用就是限制系统中执行线程的数量。 根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。 为什么要用线程池: 1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务 2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为因为消耗过多的 内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机) 线程池类 Java代码 1.package com.tdt.impl.ls; 2. 3.import java.util.LinkedList; 4. 5./** 6. * @project LocationGateway 7. * @author sunnylocus 8. * @verson 1.0.0 9. * @date Aug 2, 2008 10. * @jdk 1.4.2 11. */ 12.public class ThreadPool extends ThreadGroup { 13. private boolean isClosed = false; //线程池是否关闭 14. private LinkedList workQueue; //工作队列 15. private static int threadPoolID = 1; //线程池的id 16. public ThreadPool(int poolSize) { //poolSize 表示线程池中 的工作线程的数量 17. 18. super(threadPoolID + ""); //指定ThreadGroup的名 称

java多线程 练习

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：一个整型属性

Java线程总结

Java线程总结 在论坛上面常常看到初学者对线程的无可奈何，所以总结出了下面一篇文章，希望对一些正在学习使用java线程的初学者有所帮助。 首先要理解线程首先需要了解一些基本的东西，我们现在所使用的大多数操作系统都属于多任务，分时操作系统。正是由于这种操作系统的出现才有了多线程这个概念。我们使用的w indows，linux就属于此列。什么是分时操作系统呢，通俗一点与就是可以同一时间执行多个程序的操作系统，在自己的电脑上面，你是不是一边听歌，一边聊天还一边看网页呢？但实际上，并不上c pu在同时执行这些程序，c pu只是将时间切割为时间片，然后将时间片分配给这些程序，获得时间片的程序开始执行，不等执行完毕，下个程序又获得时间片开始执行，这样多个程序轮流执行一段时间，由于现在c pu 的高速计算能力，给人的感觉就像是多个程序在同时执行一样。 一般可以在同一时间内执行多个程序的操作系统都有进程的概念。一个进程就是一个执行中的程序，而每一个进程都有自己独立的一块内存空间，一组系统资源。在进程概念中，每一个进程的内部数据和状态都是完全独立的。因此可以想像创建并执行一个进程的系统开像是比较大的，所以线程出现了。在java中，程序通过流控制来执行程序流，程序中单个顺序的流控制称为线程，多线程则指的是在单个程序中可以同时运行多个不同的线程，执行不同的任务。多线程意味着一个程序的多行语句可以看上去几乎在同一时间内同时运行。（你可以将前面一句话的程序换成进程，进程是程序的一次执行过程，是系统运行程序的基本单位） 线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制；但与进程不同的是，同类的多个线程是共享一块内存空间和一组系统资源，而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。所以系统在产生一个线程。或者在各个线程之间切换时，负担要比进程小的多，正因如此，线程也被称为轻负荷进程(light-w eight proc ess)。一个进程中可以包含多个线程。 多任务是指在一个系统中可以同时运行多个程序,即有多个独立运行的任务，每个任务对应一个进程，同进程一样，一个线程也有从创建,运行到消亡的过程，称为线程的生命周期。用线程的状态(state)表明线程处在生命周期的哪个阶段。线程有创建，可运行，运行中，阻塞,死亡五中状态.通过线程的控制与调度可使线程在这几种状态间转化每个程序至少自动拥有一个线程，称为主线程。当程序加载到内存时，启动主线程。 [线程的运行机制以及调度模型] java中多线程就是一个类或一个程序执行或管理多个线程执行任务的能力，每个线程可以独立于其他线程而独立运行，当然也可以和其他线程协同运行，一个类控制着它的所有线程，可以决定哪个线程得到优先级，哪个线程可以访问其他类的资源，哪个线程开始执行，哪个保持休眠状态。 下面是线程的机制图： 线程的状态表示线程正在进行的活动以及在此时间段内所能完成的任务.线程有创建，可运行，运行中，阻塞，死亡五中状态。一个具有生命的线程，总是处于这五种状态之一： 1.创建状态 使用new运算符创建一个线程后，该线程仅仅是一个空对象，系统没有分配资源，称该线程处于创建状态(new thread) 2.可运行状态

最精简的java 线程池与任务队列

以下资料为java培训为大家整理： 1 import java.util.*; 2 public class WorkQueue 3 { 4 private final int nThreads;//线程池的大小 5 private final PoolWorker[] threads;//用数组实现线程池 6 private final LinkedList queue;//任务队列 7 8 public WorkQueue（int nThreads）{ 9 this.nThreads = nThreads; 10 queue = new LinkedList（）； 11 threads = new PoolWorker[nThreads]; 12 13 for （int i=0; i

21 queue.addLast（r）； 22 queue.notify（）； 23 } 24 } 25 26 private class PoolWorker extends Thread {//工作线程类 27 public void run（） { 28 Runnable r; 29 while （true） { 30 synchronized（queue） { 31 while （queue.isEmpty（）） {//如果任务队列中没有任务，等待 32 try{ 33 queue.wait（）； 34 }catch （InterruptedException ignored）{} 35 } 36 r = （Runnable） queue.removeFirst（）；//有任务时，取出任务 37 } 38 try { 39 r.run（）；//执行任务 40 }catch （RuntimeException e） { 41 // You might want to log something here 42 }

JAVA多线程简单案例.

第一页在 Java 程序中使用多线程要比在 C 或 C++ 中容易得多，这是因为Java 编程语言提供了语言级的支持。本文通过简单的编程示例来说明 Java 程序中的多线程是多么直观。读完本文以后，用户应该能够编写简单的多线程程序。 为什么会排队等待？下面的这个简单的 Java 程序完成四项不相关的任务。这样的程序有单个控制线程，控制在这四个任务之间线性地移动。此外，因为所需的资源 ? 打印机、磁盘、数据库和显示屏 -- 由于硬件和软件的限制都有内在的潜伏时间，所以每项任务都包含明显的等待时间。因此，程序在访问数据库之前必须等待打印机完成打印文件的任务，等等。如果您正在等待程序的完成，则这是对计算资源和您的时间的一种拙劣使用。改进此程序的一种方法是使它成为多线程的。四项不相关的任务class myclass { static public void main(String args[] { print_a_file(; manipulate_another_file(; access_database(; draw_picture_on_screen(; } } 在本例中，每项任务在开始之前必须等待前一项任务完成，即使所涉及的任务毫不相关也是这样。但是，在现实生活中，我们经常使用多线程模型。我们在处理某些任务的同时也可以让孩子、配偶和父母完成别的任务。例如，我在写信的同时可能打发我的儿子去邮局买邮票。用软件术语来说，这称为多个控制（或执行）线程。可以用两种不同的方法来获得多个控制线程：多个进程在大多数操作系统中都可以创建多个进程。当一个程序启动时，它可以为即将开始的每项任务创建一个进程，并允许它们同时运行。当一个程序因等待网络访问或用户输入而被阻塞时，另一个程序还可以运行，这样就增加了资源利用率。但是，按照这种方式创建每个进程要付出一定的代价：设置一个进程要占用相当一部分处理器时间和内存资源。而且，大多数操作系统不允许进程访问其他进程的内存空间。因此，进程间的通信很不方便，并且也不会将它自己提供给容易的编程模型。线程线程也称为轻型进程 (LWP。因为线程只能在单个进程的作用域内活动，所以创建线程比创建进程要廉价得多。这样，因为线程允许协作和数据交换，并且在计算资源方面非常廉价，所以线程比进程更可取。线程需要操作系统的支持，因此不是所有的机器都提供线程。Java 编程语言，作为相当新的一种语言，已将线程支持与语言本身合为一体，这样就对线程提供了强健的支持。使用 Java 编程语言实现线程Jav