JAVA中实现多线程总结

我们知道，在操作系统级别上软件的运行一般都是以进程为单位，而在每个进程的运行过程中允许同时并发执行多个不同线程，这就使得一个程序能同时执行不同的操作。使用多线程的目的是为了最大限度地利用计算机CPU资源。JAVA程序字节码最终是在JVM虚拟机下运行的，同一虚拟机进程中的不同操作都是通过多线程来运行的。在JAVA虚拟机中，线程常用有单线程和多线程，单线程指程序执行过程只是一个有效操作的序列，不同操作都有着明确的先后顺序；而多线程允许同时进行着不同的操作，这些不同的操作同时并发进行着，并由CPU时钟频率根据不同的调度方式对他们进行执行调度。

在JAVA语言中提供了丰富的多线程操纵接口，提供了各类不同的线程实现方法供我们选择，功能非常强大。在手机软件设计中，由于同样需要执行网络连接(基于HTTP的高级Internet协议通讯)、UI调度等待、UI显示幻化、游戏控制等操作需要通过后台的数据运算或UI不断更新等操作。因此在J2ME中，KVM虚拟机也提供了功能强大的多线程API，使我们同样能在J2ME中实现线程的并发运算。

在J2ME中，主要有以下三种方法实现多线程。

一、继承Thread类(https://www.sodocs.net/doc/a05633610.html,ng.Thread)

通过编写线程类继承Thread类并重写Thread类中的run()方法实现线程，当线程对象被运行时候将会自动执行run方法中的实体内容，从而开辟一个单独的线程并运行起来。

如：public class ThreadSimple extends Thread{

public ThreadSimple()

{

//constructor

}

public void run()

{

//run code entity

}

}

线程实例使用，直接创建对象并调用start()方法即可运行线程。

new ThreadSimple().start();

当执行start方法时候，将会自动运行run方法，但是执行start方法时候只做了一件事，就是将线程转化为可执行状态，然后等待操作系统进行调度并运行，因此无法保证线程能立即启动。在JAVA中，Thread类实现了Runnable接口，因此run方法是通过实现接口Runnable中的抽象方法。

二、直接实现Runnable多线程接口(https://www.sodocs.net/doc/a05633610.html,ng.Runnable)

线程接口Runnable中只有一个抽象方法run，通过实现Runnable接口中的方法的类即可创建出有多线程特征的对象，但该对象并无法使其启动线程，需要作为参数并借助Thread的构造方法构造创建对象并调用start方法对线程进行启动。

如：public class RunnablSimple implements Runnable{

public RunnableSimple()

{

//constructor

}

public void run(){

//run code entity

}

}

实现类型的对象使用：

RunnableSimple rs = new RunnableSimple();

new Thread(rs).start();

由此可见，以上两种方法都是通过Thread的start来启动线程的，实际上所有的线程操作都是封装在Thread这个类中，由Thread对象调用各种接口来控制线程。

J2ME中线程中主要方法：

void setPriority(int newPriority)，设置线程优先级，在操作系统中线程的调度是不确定性的，可以通过该方法设置相应线程的优先级别。 static void sleep(long millis) ，线程中静态方法，用于让线程进入休眠状态，执行该方法将会让线程在指定时间millis毫秒内休眠。

void start()，使现在进入可执行状态。

void run() ，线程执行主体。

void join()，等待该线程终止。

boolean isAlive()，用于判断线程是否出于Alive状态。

static void yield() ，尽量让其他线程先执行。

三、使用任务组合实现多线程

在J2ME中，同样具有JAVA中的任务处理组合类，他们分别为Timer 和TimerTask，可以使用他们实现多线程，简单说就是定时实现任务。 Timer是JAVA中的一个定时器，可以实现在某一时间做某件事或者在某一时间段做某些事，分别通过方法schedule(TimerTask tt，long

millis)和schedule(TimerTask tt，long start，long off)。

TimerTask是一个任务类，通过继承该类并覆盖方法run即可创建一个任务。

如：public class TimerTaskS extends TimerTask{

public TimerTaskS(){

//constructor

}

public void run(){

//run code entity

}

}

任务调用：

Timer timer = new Timer();

//3秒钟后执行任务

timer.schedule(new TimerTaskS()，3000);

//3秒钟后执行任务并且之后每5秒钟执行一次

timer.schedule(new TimerTaskS()，3000，5000);

有此可见在使用计时任务可以达到实现线程的效果，分别执行不同的并发操作，通过Timer类对象来操作TimerTask对象，通过schedule方法来计时执行任务，在结束任务的时候，通常使用cancel()来实现。

通常情况下，在J2ME软件中我们通过手机按键来触发一系列相应的操作，在程序响应处理过程中较多会涉及网络操作、数据存储等相对消耗时间和资源的操作，而这些操作往往需要一定的时间才能完成，因此在处理按键响应过程中通常我们需要建立线程处理，避免程序出现死机现象。

public void commandAction(Command c, Displayable s) {

　if(c==do1Com){

//创建实现接口线程

new Thread(new RunnableSimple()).start()；

　}

　else if(c==do2Com){

//创建继承Thread线程

new ThreadSimple().start();

　}

else{

//创建任务线程

new Timer().schedule(new TimerTaskS(),3000,20); }

}

Java多线程和输入输出流

班级：13科技2班学号：201324131225 姓名：许耿宁 Java多线程和输入输出流 一、实验目的： 1.熟悉利用Thread类建立多线程方法。 2.熟悉利用Thread接口建立多线程方法。 3.熟悉Java的文件读写机制，练习输入输出流的使用。 二、实验内容： 1.阅读下列程序，分析并上机检验其功能。 public class DelayRunnable implements Runnable{ private static int count=0; private int no; private int delay; public DelayRunnable(){ count++; no=count; } public void run(){ try{ for (int i=0;i<10;i++){ delay=(int)(Math.random()*5000); Thread.sleep(delay); System.out.println("Thread "+no+" with a delay "+delay); } }catch(InterruptedException e){} } } class MyRunnable{ public static void main(String args[]){ DelayRunnable r1 = new DelayRunnable();

DelayRunnable r2 = new DelayRunnable(); Thread thread1=new Thread(r1); Thread thread2=new Thread(r2); thread1.start(); thread2.start(); try{ Thread.sleep(1000); }catch(InterruptedException e){ System.out.println("Thread wrong"); } } } 2.将上列程序利用Runnable接口改写，并上机检验。 3.创建简单的程序ThreeThread.java，该程序将创建三个线程，每个线程应当显示它所运行的时间（可以考虑使用Date类或Calendar类）。 4.键盘输入10个整数，从小到大进行排序。 5.接收键盘输入的字符串，用FileInputStream类将字符串写入文件，用 FileOutputStream类读出文件内容显示在屏幕上。 6.将一个文本文件的内容按行读出，每读出一行就顺序加上行号，并写入到另一个文件中。 三、实验要求： 1.通过实验掌握Thread 、Runnable使用方法； 2.程序必须能够实现多线程； 3.程序必须能够完成题目要求； 4.通过实验掌握文件输入输出流的使用方法； 5.程序必须能够从键盘接收字符串并保存在文件中； 6.程序必须能够读出文件内容显示在屏幕上； 7.写出实验报告。 四、实验代码及截图： 第一题： 在编译器上运行程序得到截图所示结果：

JAVA线程程序设计(小时钟)实验报告(附完整代码)

线程程序设计 一、课题内容和要求 内容：设计和编写一个编写一个指针式时钟程序，应用线程实现时钟的走动。 要求：本实验旨在通过实验，培养学生将JAVA 线程的相关知识点（包括线程调度，线程同步等）有机结合并加以综合应用，在实验中设计多线程程序的能力。 二、设计思路分析 class Clock:一个指针式时钟的主类 class Layout: 添加窗口和时钟组件 class ClockPaint:定义时钟组件 三、概要设计 public class Clock extends JFrame { public static void main(String[] s) ; } class Layout extends JFrame { public Layout(); } class ClockPaint extends JPanel implements Runnable { int x, y, r; int h, m, s; double rad = Math.PI / 180; public ClockPaint(int x, int y, int r); public void paint(Graphics g); public void run(); } 时钟的绘制:

运行时钟: 四、详细设计 import java.awt.*; import javax.swing.*; import java.util.*; public class Clock extends JFrame { public static void main(String[] s) { new Layout(); } } class Layout extends JFrame {// 添加窗口和时钟组件public Layout() { ClockPaint cp = new ClockPaint(20, 20, 70); add(cp);

java线程学习总结

java线程学习总结1(java thread培训总结1) 1．线程中一些基本术语和概念 (2) 1.1线程的几个状态 (2) 1.2 Daemon线程 (2) 1.3锁的定义 (2) 1.4死锁 (2) 1.5.Java对象关于锁的几个方法 (3) 1.6锁对象(实例方法的锁) (3) 1.7类锁 (4) 1.8.线程安全方法与线程不安全方法 (4) 1.9类锁和实例锁混合使用 (4) 1.10锁的粒度问题 (4) 1.11.读写锁 (5) 1.12 volatile (5) 2．线程之间的通讯 (5) 2.1屏障 (6) 2.2.锁工具类 (6) 2.3.条件变量 (6) 3. Java线程调度 (7) 3.1 Java优先级 (7) 3.2. 绿色线程 (7) 3.3 本地线程 (7) 3.4 Windows本地线程 (7) 3.5线程优先级倒置与继承 (8) 3.6循环调度 (8) 4.线程池 (8) 5工作队列 (9) 6.参考资料 (10)

1．线程中一些基本术语和概念 1.1线程的几个状态 初始化状态 就绪状态 运行状态 阻塞状态 终止状态 1.2 Daemon线程 Daemon线程区别一般线程之处是：主程序一旦结束，Daemon线程就会结束。 1.3锁的定义 为了协调多个并发运行的线程使用共享资源才引入了锁的概念。 1.4死锁 任何多线程应用程序都有死锁风险。当一组线程中的每一个都在等待一个只 有该组中另一个线程才能引起的事件时，我们就说这组线程死锁了。换一个说法就是一组线程中的每一个成员都在等待别的成员占有的资源时候，就可以说这组线程进入了死锁。死锁的最简单情形是：线程 A 持有对象X 的独占锁，并且在等待对象Y 的锁，而线程 B 持有对象Y 的独占锁，却在等待对象X 的锁。除非有某种方法来打破对锁的等待（Java 锁定不支持这种方法），否则死锁的线程将永远等下去。

多线程总结

最近想将java基础的一些东西都整理整理，写下来，这是对知识的总结，也是一种乐趣。已经拟好了提纲，大概分为这几个主题： java线程安全，java垃圾收集，java并发包详细介绍，java profile和jvm性能调优。慢慢写吧。本人jameswxx原创文章，转载请注明出处，我费了很多心血，多谢了。关于java线程安全，网上有很多资料，我只想从自己的角度总结对这方面的考虑，有时候写东西是很痛苦的，知道一些东西，想用文字说清楚，却不是那么容易。我认为要认识 java线程安全，必须了解两个主要的点：java的内存模型，java的线程同步机制。特别是内存模型，java的线程同步机制很大程度上都是基于内存模型而设定的。从暂时写得比较仓促，后面会慢慢补充完善。 浅谈java内存模型 不同的平台，内存模型是不一样的，但是jvm的内存模型规范是统一的。java的多线程并发问题最终都会反映在java的内存模型上，所谓线程安全无非要控制多个线程对某个资源的有序访问或修改。java的内存模型，要解决两个主要的问题：可见性和有序性。我们都知道计算机有高速缓存的存在，处理器并不是每次处理数据都是取内存的。JVM定义了自己的内存模型，屏蔽了底层平台内存管理细节，对于java开发人员，要解决的是在jvm内存模型的基础上，如何解决多线程的可见性和有序性。 那么，何谓可见性？多个线程之间是不能互相传递数据通信的，它们之间的沟通只能通过共享变量来进行。Java内存模型（JMM）规定了jvm有主内存，主内存是多个线程共享的。当new一个对象的时候，也是被分配在主内存中，每个线程都有自己的工作内存，工作内存存储了主存的某些对象的副本，当然线程的工作内存大小是有限制的。当线程操作某个对象时，执行顺序如下： (1) 从主存复制变量到当前工作内存 (read and load) (2) 执行代码，改变共享变量值 (use and assign) (3) 用工作内存数据刷新主存相关内容 (store and write) JVM规范定义了线程对主存的操作指令：read，load，use，assign，store，write。当一个共享便变量在多个线程的工作内存中都有副本时，如果一个线程修改了这个共享变量，那么其他线程应该能够看到这个被修改后的值，这就是多线程的可见性问题。 那么，什么是有序性呢？线程在引用变量时不能直接从主内存中引用,如果线程工作内存中没有该变量,则会从主内存中拷贝一个副本到工作内存中,这个过程为read-load,完成后线程会引用该副本。当同一线程再度引用该字段时,有可能重新从主存中获取变量副本(read-load-use),也有可能直接引用原来的副本 (use),也就是说 read,load,use顺序可以由JVM实现系统决定。 线程不能直接为主存中中字段赋值，它会将值指定给工作内存中的变量副本(assign),完成后这个变量副本会同步到主存储区(store- write)，至于何时同步过去，根据JVM实现系统决定.有该字段,则会从主内存中将该字段赋值到工作内存中,这个过程为read-load,完成后线程会引用该变量副本，当同一线程多次重复对字段赋值时,比如： for(int i=0;i<10;i++) a++; 线程有可能只对工作内存中的副本进行赋值,只到最后一次赋值后才同步到主存储区，所以assign,store,weite顺序可以由JVM实现系统决定。假设有一个共享变量x，线程a执行x=x+1。从上面的描述中可以知道x=x+1并不是一个原子操作，它的执行过程如下：

java学习整体总结

CoreJava部分 1 简述下java基本数据类型及所占位数，java基本数据类型：4类8种 整数类型：byte(1byte),short(2byte),int(4byte),long(8byte) 浮点类型：float(4byte),double(8byte) 字符类型：char(2byte) 逻辑类型：boolean(false/true 1byte) 2 说出5个启动时异常 RunTimeException ------NullPointerException ------ArrayIndexOutOfBoundsException ------ClassCastException ------NumberFormatException 3 HashMap 和HashTable的区别： 1HashMap 允许空键值对，HashTable不允许 2HashMap不是线程安全的，HashTable是 3HashMap直接实现Map接口，HashTable继承Dictionary类 4. ArrayList,Vector,LinkedList存储性能和区别 它们都实现了List接口 ArrayList和Vector都是基于数组实现的 LinkedList基于双向循环链表（查找效率低，添加删除容易） ArrayList不是线程安全的而Vector是线程安全的，所有速度上 ArrayList高于Vector 5. Collection和Collections的区别 Collection是集合类的上级接口，继承与他的接口主要有Set和List Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全等操作。 6 List、Map、Set三个接口，存取元素时，各有什么特点？ List以特定次序来持有元素，可有重复元素。 Set 无法持有重复元素，内部排序 Map保存key-value值，value可多值。 7 final,finally,finalize的区别 Final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承 Finally 是异常处理语句结构的一部分，表示总是执行 Finalize 是Object类的一个方法，在垃圾收集时的其他资源回收，例如关闭文件等。 8 Overload和Override的区别。Overload的方法是否可以改变返回值的

java并发编程艺术总结.

1、并发编程的挑战 上下文切换：CPU通过时间片分配算法来循环执行任务，在切换任务的过程中，会保存上一个任务的状态，以便在下次切换回这个任务时，可以再加载这个任务的状态。 减少上下文切换的方法：无锁并发编程、CAS算法、使用最少线程和使用协程 2、Java并发机制的底层实现原理 Java代码编译后java字节码然后加载到JVM然后转化为CUP执行的汇编，java的并发依赖于JVM的实现与CPU的指令。 1. Volatile的应用 可见性：当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。 后面还是详细介绍volatile关键字 2. synchronized的实现原理与应用 1) synchronized简介 synchronized在JVM中实现，JVM基于进入与退出Monitor对象来实现方法同步与代码块同步，在同步代码块前后分别形成monitorenter和monitorexit这两个字节码。synchronized的锁存放在java对象头里，在对象头里有关于锁的信息：轻量级锁，重量级锁，偏向锁。（对象头里还包括：GC标记、分代年龄、线程ID、HashCode等。） 2) 锁的介绍 级别从低到高：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，锁能升级不能降级，目的是提高获取锁和释放锁的效率。 偏向锁： 在大多数情况下，锁不仅不存在多线程竞争，而且总是由同一个线程多次获得。

为了让线程获得锁的代价更低而引入了偏向锁。 当一个线程访问同步块并获取锁（对象）时，会在对象头里记录偏向锁的线程ID。以后该线程进入与退出同步块时不需要进行CAS操作来加锁和解锁。如果在运行过程中，遇到了其他线程抢占锁，则持有偏向锁的线程会被挂起，JVM会尝试消除它身上的偏向锁，将锁恢复到标准的轻量级锁。 轻量级锁： 线程通过CAS来获取锁（线程栈帧中有存储锁记录的空间，将Mask Word复制到锁记录中，然后尝试使用CAS将对象头中的Mask Word替换成指向锁记录的指针），如果成功，就获取锁，失败就尝试自旋来获取锁。 重量级锁： 为了避免在轻量级中无用的自旋（比如获取到锁的线程被阻塞住了），JVM可以将锁升级成重量级。当锁处于这个状态时，其他线程试图获取锁时，都会被阻塞住，当持有锁的线程释放锁之后会唤醒这些线程。 锁优点缺点使用场景 偏向锁加锁与解锁不需要 额外的消耗。线程存在竞争时， 会带来额外的锁撤 销的消耗 适用于只有一个 线程访问同步块 轻量级锁竞争的线程不会阻 塞，提高了程序的 响应速度始终得不到锁竞争 的线程，自旋消耗 CPU 追求响应时间， 同步块执行速度 非常快 重量级锁线程竞争不使用自 旋，不会消耗CPU 线程阻塞，响应时 间缓慢 追求吞吐量，同 步块执行时间较 长 3. 原子操作的实现原理 原子：不能被中断的一个或一系列操作。 在java中可以通过锁和循环CAS的方式来实现原子操作。 1) 使用循环CAS实现原子操作 利用处理器提供的CAS指令来实现，自旋CAS现在的基本思路就是循环进

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 2 实验项目： 多线程实验 指导教师： **** 实验位置： 电信楼机房 姓 名： *** 学 号： **** 班 级： **** 日 期： 一、实验目的 1、掌握多线程编程的特点和工作原理； 2、掌握编写线程程序的方法 3、了解线程的调度和执行过程 4、掌握线程同步机理 二、实验环境 windows 记事本，java jdk 1.60版本，cmd 命令运行窗口 三、实验内容 实验一： 应用Java 中线程的概念写一个Java 程序（包括一个测试线程程序类TestThread ，一个Thread 类的子类PrintThread ）。在测试程序中用子类PrintThread 创建2个线程，使得其中一个线程运行时打印10次“线程1正在运行”，另一个线程运行时打印5次“线程2正在运行 源程序： public class A { public static void main(String args[]) {

Test1 A1; Test2 A2; A1=new Test1(); A2=new Test2(); A1.start(); A2.start(); } } class PrintThread extends Thread { } class Test1 extends PrintThread { public void run() { for(int i=1;i<=10;i++) { System.out.println("线程1正在运行！"); } } } class Test2 extends PrintThread { public void run() { for(int i=1;i<=5;i++) { System.out.println("线程2正在运行！"); } } } 运行结果：

武汉理工多线程总结实验报告

武汉理工大学 面向对象与多线程综合实验 总结报告 学院：计算机科学与技术学院 指导教师： xxxx 学生姓名：xxx 学号： xxxx 班级： xxxx 2015-2016年第一学期

一、功能说明 这次实验主要实现一个档案管理系统，利用Java语言以及eclipse 编译器、数据库等工具来进行开发。以下为已完成的功能： 1.通过父类、子类、抽象类等实现了封装、继承与多态。 2.使用try-catch语句实现了异常处理。 3.通过输入输出流事现了文件的上传和下载。 4.用图形化用户界面事现了所有子菜单。 5.实现与Mysql数据库的连接，并且能进行基本的数据库查询、修改、录入等基本操作 二、实现目录及文件说明 实验工程目录如下图

实现目录包文件 封装、继承与多态Java.util.* DataProcessing.java User.java Administrator.java Main.java Operator.java Browser.java 异常处理Java.util.* Java.sql.* DataProcessing.java User.java Administrator.java Main.java Operator.java Browser.java 输入输出流Java.util.* Java.sql.* Java.io.* UserManager.java Main.java User.java DocManager.java Administrator.java Doc.java Operator.java Browser.java GUI设计Java.util.*J java.sql.* Java.io.* Java.awt.* Javax.swing.* UserManager.java Login.java User.java DocManager.java Administrator.java Doc.java Operator.java Browser.java JDBC数据库操作Java.util.* Java.awt.* Java.sql.* Javax.swing.* Java.io.* UserManager.java Login.java User.java DocManager.java Administrator.java Doc.java Operator.java Browser.java PasswordmismatchException.j ava NoUserFoundException.java 文件说明： 数据库登录系统是一个工程，在工程中的包中是实现功能的java源文件，包括DocManager.java、UserManager.java、User.java、Doc.java等一系列源文件，在各个源文件中是实现功能的具体类。 三、代码说明（只贴出部分重要的代码） class Doc{ public String getID() { return ID;} public void setID(String iD) { ID = iD;} public String getCreator() { return creator;} public void setCreator(String creator) { this.creator = creator;}

JAVA中实现多线程总结

我们知道，在操作系统级别上软件的运行一般都是以进程为单位，而在每个进程的运行过程中允许同时并发执行多个不同线程，这就使得一个程序能同时执行不同的操作。使用多线程的目的是为了最大限度地利用计算机CPU资源。JAVA程序字节码最终是在JVM虚拟机下运行的，同一虚拟机进程中的不同操作都是通过多线程来运行的。在JAVA虚拟机中，线程常用有单线程和多线程，单线程指程序执行过程只是一个有效操作的序列，不同操作都有着明确的先后顺序；而多线程允许同时进行着不同的操作，这些不同的操作同时并发进行着，并由CPU时钟频率根据不同的调度方式对他们进行执行调度。 在JAVA语言中提供了丰富的多线程操纵接口，提供了各类不同的线程实现方法供我们选择，功能非常强大。在手机软件设计中，由于同样需要执行网络连接(基于HTTP的高级Internet协议通讯)、UI调度等待、UI显示幻化、游戏控制等操作需要通过后台的数据运算或UI不断更新等操作。因此在J2ME中，KVM虚拟机也提供了功能强大的多线程API，使我们同样能在J2ME中实现线程的并发运算。 在J2ME中，主要有以下三种方法实现多线程。 一、继承Thread类(https://www.sodocs.net/doc/a05633610.html,ng.Thread) 通过编写线程类继承Thread类并重写Thread类中的run()方法实现线程，当线程对象被运行时候将会自动执行run方法中的实体内容，从而开辟一个单独的线程并运行起来。 如：public class ThreadSimple extends Thread{ public ThreadSimple() { //constructor } public void run() { //run code entity } } 线程实例使用，直接创建对象并调用start()方法即可运行线程。 new ThreadSimple().start(); 当执行start方法时候，将会自动运行run方法，但是执行start方法时候只做了一件事，就是将线程转化为可执行状态，然后等待操作系统进行调度并运行，因此无法保证线程能立即启动。在JAVA中，Thread类实现了Runnable接口，因此run方法是通过实现接口Runnable中的抽象方法。

Java线程总结

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

24. 多线程(02)-JAVA多线程中线程运行状态、线程的休眠、线程的强制运行

24. 多线程（02） 本季知识点：线程的控制方法。本季继续介绍了JAVA多线程中线程运行状态、线程的休眠、线程的强制运行等常用的线程操作方法。 blog: [零基础学JAVA]Java SE应用部分-24.多线程（02） 2009-02-16 上季内容回顾： 多线程的两种实现方式： · Thread · Runnable 最终都要求使用Thread类中start()方法启动多线程 本季主要知识点： 线程的控制方法 线程的状态转换 所有的线程实际上是同时启动的，只是抢占CPU的资源的顺序不同。 线程名称的设置及取得 在线程中所有的操作类都是在一个类—— Thread类. 从提供的方法上来看：多线程中提供了getName 和setName则应该可以推断出在Thread类中必然有一个name属性。

ThreadDemo01: 运行结果：

在程序中，我们没有设置Thread-0名称哈，下面我们设置其名称 再来验证下效果 main线程是由对象进行调用的，所以是由主线程控制

从以上题目我们应该知道，我们之前所运行的所有的JAVA程序都是在线程上运行的。 java 类名称 --> 启动JVM的进程 里面的main 方法实际上就是一个在JVM进程上划分的线程。 如果没有为线程设置名字，则线程的默认名字为 Thread-x（x：表示数字，从0开始） 如果计数是往上增1，则所有对象肯定是共享同一个变量，则此变量肯定是static类型的。 看下效果：

问题： 问在JAVA程序中，每一次运行至少启动几个线程呢？ ·主线程（main） ·垃圾收集线程（GC） 刚才设置名字的时候是在Thread类的对象创建完之后在设置名字的，可以在构造方法处设置线程名称：public Thread(Runnable target,String name) ;

java多线程实验报告

北京建筑大学 理学院信息与计算科学专业实验报告 课程名称java语言程序设计实验名称java多线程实验地点大兴专业机房 姓名尹栎中班级信141 学号201407010111 指导教师靳旭玲成绩日期2016.11.26 （1）了解线程的概念。 （2）学习简单的多线程编程。 【实验任务】 （1）阅读给定的Java Application程序，按要求回答问题并写出运行结果。 （2）按要求编写一个Java Application程序，并编译、运行这个程序。 【实验内容】 1．输入下面的Java Application程序，运行该程序，并简要分析程序的运行结果。 class SimpleThread extends Thread { public SimpleThread(String str) { super(str); //调用其父类的构造方法 } public void run() { //重写run方法 for (int i = 0; i < 10; i++) { System.out.println(i + " " + getName()); //打印次数和线程的名字 try { sleep((int)(Math.random() * 1000)); //线程睡眠，把控制权交出去 } catch (InterruptedException e) { } } System.out.println("DONE! " + getName()); //线程执行结束 } } public class TwoThreadsTest { public static void main (String args[]) { new SimpleThread("First").start(); //第一个线程的名字为First new SimpleThread("Second").start(); //第二个线程的名字为Second } } 2．编写程序，将上面多线程程序用Runnable接口来实现。

Java多线程实验报告

西安邮电大学 （计算机学院） 课内实验报告 实验名称：多线程 专业名称：计算机科学与技术 班级：计科1405班 学生姓名：高宏伟 学号：04141152 指导教师：刘霞林 实验日期：2016.12.08

一、实验目的 1．线程的概念、线程的生命周期。 2．多线程的编程：继承Thread类与使用Runnable接口。 3．使用多线程机制实现动画。 二、实验要求 1. 掌握利用JA V A语言编写多线程程序的方法。 2. 掌握线程的调度方法。 3. 掌握多线程环境中GUI程序的编写方法。 三、实验内容 （一）汉字打字练习。 ?实验要求： 编写一个Java应用程序，在主线程中再创建一个Frame类型的窗口，在该窗口中再创建1个线程giveWord。线程giveWord每隔2秒钟给出一个汉字，用户使用一种 汉字输入法将该汉字输入到文本框中。 ?程序模板： WordThread.java import java.awt.*; public class WordThread extends Thread { char word; int k=19968; Label com; WordThread(Label com) { https://www.sodocs.net/doc/a05633610.html,=com; } public void run() { k=19968; while(true) { word=(char)k; com.setText(""+word); try{ 【代码1】//调用sleep方法使得线程中断6000豪秒 } catch(InterruptedException e){} k++; if(k>=29968) k=19968; }

深入理解Java多线程核心知识：跳槽面试必备

深入理解-Jaｖa-多线程核心知识：跳槽面试必备

————————————————————————————————作者：————————————————————————————————日期： ?

深入理解Java 多线程核心知识:跳槽面试必备 多线程相对于其他Jaｖa 知识点来讲,有一定的学习门槛,并且了解起来比较费劲。在平时工作中如若使用不当会出现数据错乱、执行效率低(还不如单线程去运行)或者死锁程序挂掉等等问题，所以掌握了解多线程至关重要。 本文从基础概念开始到最后的并发模型由浅入深,讲解下线程方面的知识。 概念梳理 本节我将带大家了解多线程中几大基础概念。 并发与并行 并行,表示两个线程同时做事情。 并发,表示一会做这个事情,一会做另一个事情，存在着调度。单核CPU 不可能存在并行(微观上）。 临界区 临界区用来表示一种公共资源或者说是共享数据，可以被多个线程使用。但是每一次,只能有一个线程使用它,一旦临界区资源被占用,其他线程要想使用这个资源，就必须等待。

阻塞与非阻塞 阻塞和非阻塞通常用来形容多线程间的相互影响。比如一个线程占用了临界区资源,那么其它所有需要这个资源的线程就必须在这个临界区中进行等待，等待会导致线程挂起。这种情况就是阻塞。 此时,如果占用资源的线程一直不愿意释放资源,那么其它所有阻塞在这个临界区上的线程都不能工作。阻塞是指线程在操作系统层面被挂起。阻塞一般性能不好,需大约８万个时钟周期来做调度。 非阻塞则允许多个线程同时进入临界区。 死锁 死锁是进程死锁的简称,是指多个进程循环等待他方占有的资源而无限的僵持下去的局面。

Java多线程学习总结

u Java 线程及进程 u Java 中的线程类(Thread) u Java 中的 Runnable 接口 u两种实现多线程方式的对比分析 u Java 中线程的同步 早期的Winodw3.x下,进程是最小运行单位.在Window95/NT下,每个进程还可以 启动几个线程,比如每下载一个文件可以单独开一个线程.在 Windows 95/NT 下, 线程是最小单位.WINDOWS 的多任务特性使得线程之间独立进行,但是它们彼此 共享虚拟空间,也就是共用变量,线程有可能会同时操作一片内存. n (1) 线程的划分尺度小于进程,使得多线程程序的并发性高 n (2)进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极 大地提高了程序的运行效率. n (3)每个独立的线程有一个程序运行的入口,顺序执行序列和程序的出口, 但是线程不能独立执行,必须依存在应用程序中,由应用程序提供多个线 程执行控制. n 1. 虚拟的 CPU，由 https://www.sodocs.net/doc/a05633610.html,ng.Thread 类封装和虚拟； n 2. CPU 所执行的代码，传递给 Thread 类对象； n 3. CPU 所处理的数据，传递给 Thread 类对象。 Java 中的线程类(Thread) n Java 的线程是通过 https://www.sodocs.net/doc/a05633610.html,ng.Thread 类来控制的,一个 Thread 类的对象 代表一个线程,而且只能代表一个线程.通过Thread类和它定义的对象,我 们可以获得当前线程对象,获取某一线程的名称,可以实现控制线程暂停 一段时间等功能,

n package com.yzy? n import java.sql.*? n class Thread1 extends Thread { n private int n? n public Thread1(int n) { n this.n = n? n } n public void run() { n for (int i = 0? i < 100? i++) { n System.out.println("第" + n + "个线程的第" + i + "次运行")? n } n } n } n public class SimpleSwing { n public static void main(String[] args) { n Thread1 t1 = new Thread1(1)? n Thread1 t2 = new Thread1(2)? n t1.run()?单线程运行 n t2.run()?单线程运行 n System.out.println("主线程结束")? n } n } n 程序执行完t1.run(),再执行t2.run(),最后结束主线程,显然这是一个单

JAVA多线程的实验报告-

深圳大学实验报告课程名称：Java程序设计 实验项目名称：线程 学院：计算机与软件学院 专业： 指导教师：谭舜泉 报告人：学号：班级：3班 实验时间：2012年12月13日 实验报告提交时间：2012年12月26日 教务部制

一、实验内容： 8.2.3 吵醒休眠的线程 实验代码： class Shop implements Runnable { Thread zhangWorker,wangWorker,boss; Shop() { boss=new Thread(this);//创建boss，Shop对象为boss目标对象 zhangWorker=new Thread(this); wangWorker=new Thread(this); zhangWorker.setName("张工"); wangWorker.setName("王工"); boss.setName("老板"); } public void run() { int i=0; if(Thread.currentThread()==zhangWorker) { while(true) { try {i++; System.out.printf("\n%s已搬运了%d箱苹果 \n",zhangWorker.getName(),i); if(i==3)return; Thread.sleep(10000); }//zhangWorker休眠10秒} catch(InterruptedException e){System.out.printf("\n%s 让%s继续工作",boss.getName(),zhangWorker.getName());} } } else if(Thread.currentThread()==wangWorker) { while(true) { try

java多线程实验报告

Java实验程序设计实验报告 实验名称：多线程 一：实验目的 1、掌握线程和多线程的概念。 2、掌握创建线程的两种方法及其区别。 3、了解线程的启动、终止、同步、互斥和优先级等概念。 二：实验内容 1、编写一个程序，其功能是运行之后，其中有一个线程可以输出20次你的学号，另一个线程会输出20次你的姓名。 2、编写一个图形界面程序，运行之后，让其中有一个线程能在界面上“实时”显示系统当前时间（精确到秒获取时间可查询java.util.Calendar类，它包含了多个用于获得系统时间的函数）。另让一个线程可以在界面上提示当前系统时间下用户该做什么工作（例如当程序判断出系统时间现在是8：00到9：00，则提示用户该上课；现在是23：00到8：00，则提示用户该休息。具体测试时可以将时间段限制到秒级，以便及时查看到程序运行中提示信息的变化）。 三：实验设计 四：实验测试及运行结果 实验一；20次输出姓名，学号实验二：一个界面的左边显示当时时间，显示的时间会随时间的改变而改变，右边显示某个时间段该干什么，比如该睡觉，该上课，该自习。 五：问题与总结 通过这次实验学会了怎么使用多线程。 六：附录 package shiyan6_1; class MyThread implements Runnable { public MyThread() {

// 构造函数的代码，根据需要来写 } public void run() { for (int i = 1; i <= 20; i++) { System.out.println("第" + i + "次执行线程" + Thread.currentThread().getName()); try { Thread.currentThread().sleep(500);// 睡眠500ms } catch (InterruptedException e) { } } } public static void main(String args[]) { Thread t1 = new Thread(new MyThread(), "学号"); // 创建线程1的对象,并 // 通过第二个参数将其命名为thread 1 Thread t2 = new Thread(new MyThread(), "姓名"); // 创建线程2的对象,并 // 通过第二个参数将其命名为thread 2 t1.start(); // 启动两个线程运行