1. 如何学习java中的多线程
几乎所有使用 AWT 或 Swing 编写的画图程序都需要多线程。但多线程程序会造成许多困难，刚开始编程的开发者常常会发现他们被一些问题所折磨，例如不正确的程序行为或死锁。
在本文中，我们将探讨使用多线程时遇到的问题，并提出那些常见陷阱的解决方案。
线程是什么？
一个程序或进程能够包含多个线程，这些线程可以根据程序的代码执行相应的指令。多线程看上去似乎在并行执行它们各自的工作，就像在一台计算机上运行着多个处理机一样。在多处理机计算机上实现多线程时，它们确实可以并行工作。和进程不同的是，线程共享地址空间。也就是说，多个线程能够读写相同的变量或数据结构。
编写多线程程序时，你必须注意每个线程是否干扰了其他线程的工作。可以将程序看作一个办公室，如果不需要共享办公室资源或与其他人交流，所有职员就会独立并行地工作。某个职员若要和其他人交谈，当且仅当该职员在“听”且他们两说同样的语言。此外，只有在复印机空闲且处于可用状态（没有仅完成一半的复印工作，没有纸张阻塞等问题）时，职员才能够使用它。在这篇文章中你将看到，在 Java 程序中互相协作的线程就好像是在一个组织良好的机构中工作的职员。
在多线程程序中，线程可以从准备就绪队列中得到，并在可获得的系统 CPU 上运行。操作系统可以将线程从处理器移到准备就绪队列或阻塞队列中，这种情况可以认为是处理器“挂起”了该线程。同样，Java 虚拟机 (JVM) 也可以控制线程的移动??在协作或抢先模型中??从准备就绪队列中将进程移到处理器中，于是该线程就可以开始执行它的程序代码。
协作式线程模型允许线程自己决定什么时候放弃处理器来等待其他的线程。程序开发员可以精确地决定某个线程何时会被其他线程挂起，允许它们与对方有效地合作。缺点在于某些恶意或是写得不好的线程会消耗所有可获得的 CPU 时间，导致其他线程“饥饿”。
在抢占式线程模型中，操作系统可以在任何时候打断线程。通常会在它运行了一段时间（就是所谓的一个时间片）后才打断它。这样的结果自然是没有线程能够不公平地长时间霸占处理器。然而，随时可能打断线程就会给程序开发员带来其他麻烦。同样使用办公室的例子，假设某个职员抢在另一人前使用复印机，但打印工作在未完成的时候离开了，另一人接着使用复印机时，该复印机上可能就还有先前那名职员留下来的资料。抢占式线程模型要求线程正确共享资源，协作式模型却要求线程共享执行时间。由于 JVM 规范并没有特别规定线程模型，Java 开发员必须编写可在两种模型上正确运行的程序。在了解线程以及线程间通讯的一些方面之后，我们可以看到如何为这两种模型设计程序。
线程和 Java 语言
为了使用 Java 语言创建线程，你可以生成一个 Thread 类（或其子类）的对象，并给这个对象发送 start() 消息。（程序可以向任何一个派生自 Runnable 接口的类对象发送 start() 消息。）每个线程动作的定义包含在该线程对象的 run() 方法中。run 方法就相当于传统程序中的 main() 方法；线程会持续运行，直到 run() 返回为止，此时该线程便死了。
上锁
大多数应用程序要求线程互相通信来同步它们的动作。在 Java 程序中最简单实现同步的方法就是上锁。为了防止同时访问共享资源，线程在使用资源的前后可以给该资源上锁和开锁。假想给复印机上锁，任一时刻只有一个职员拥有钥匙。若没有钥匙就不能使用复印机。给共享变量上锁就使得 Java 线程能够快速方便地通信和同步。某个线程若给一个对象上了锁，就可以知道没有其他线程能够访问该对象。即使在抢占式模型中，其他线程也不能够访问此对象，直到上锁的线程被唤醒、完成工作并开锁。那些试图访问一个上锁对象的线程通常会进入睡眠状态，直到上锁的线程开锁。一旦锁被打开，这些睡眠进程就会被唤醒并移到准备就绪队列中。
在 Java 编程中，所有的对象都有锁。线程可以使用 synchronized 关键字来获得锁。在任一时刻对于给定的类的实例，方法或同步的代码块只能被一个线程执行。这是因为代码在执行之前要求获得对象的锁。继续我们关于复印机的比喻，为了避免复印冲突，我们可以简单地对复印资源实行同步。如同下列的代码例子，任一时刻只允许一位职员使用复印资源。通过使用方法（在 Copier 对象中）来修改复印机状态。这个方法就是同步方法。只有一个线程能够执行一个 Copier 对象中同步代码，因此那些需要使用 Copier 对象的职员就必须排队等候。
class CopyMachine {
public synchronized void makeCopies(Document d, int nCopies) {
//only one thread executes this at a time
}
public void loadPaper() {
//multiple threads could access this at once!
synchronized(this) {
//only one thread accesses this at a time
//feel free to use shared resources, overwrite members, etc.
}
}
}
Fine-grain 锁
在对象级使用锁通常是一种比较粗糙的方法。为什么要将整个对象都上锁，而不允许其他线程短暂地使用对象中其他同步方法来访问共享资源？如果一个对象拥有多个资源，就不需要只为了让一个线程使用其中一部分资源，就将所有线程都锁在外面。由于每个对象都有锁，可以如下所示使用虚拟对象来上锁：
class FineGrainLock {
MyMemberClass x, y;
Object xlock = new Object(), ylock = new Object();
public void foo() {
synchronized(xlock) {
//access x here
}
//do something here - but don�0�7t use shared resources
synchronized(ylock) {
//access y here
}
}
public void bar() {
synchronized(this) {
//access both x and y here
}
//do something here - but don�0�7t use shared resources
}
}
若为了在方法级上同步，不能将整个方法声明为 synchronized 关键字。它们使用的是成员锁，而不是 synchronized 方法能够获得的对象级锁。
2. Java多线程编程
作者 natrium 一 理解多线程多线程是这样一种机制 它允许在程序中并发执行多个指令流 每个指令流都称为一个线程 彼此间互相独立 线程又称为轻量级进程 它和进程一样拥有独立的执行控制 由操作系统负责调度 区别在于线程没有独立的存储空间 而是和所属进程中的其它线程共享一个存储空间 这使得线程间的通信远较进程简单 多个线程的执行梁卜是并发的 也就是在逻辑上 同时 而不管是否是物理上的 同时 如果系统只有一个CPU 那么真正的 同时 是不可能的 但是由于CPU的速度非常快 用户感觉不到其中的区别 因此我们也不用关心它 只需要设想各个线程是同时执行即可 多线程和传统的单线程在程序设计上最大的区别在于 由于各个线程的控制流彼此独立 使得各个线程之间的代码是乱序执行的 由此带来的线程调度 同步等问题 将在以后探讨 二 在Java中实现多线程我们不妨设想 为了创建一个新的线程 我们需要做些什么？很显然 我们必须指明这个线程所要执行的代码 而这就是在Java中实现多线程我们所需要做的一切！真是神奇！Java是如何做到这一点的？通过类！作为一个完全面向对象的语言 Java提供了类 java lang Thread 来方便多线程编程 这个类提供了大量的方法来方便我们控制自己的各个线程 我们以后的讨论都将围绕这个类进行 那么如何提供给 Java 我们要线程执行的代码呢？让我们来看一看 Thread 类 Thread 类最重要的方法是 run() 它为Thread 类的方法 start() 所调用 提供我们的线程所要执行的代码 为了指定我们自己的代码 只需要覆盖它！方法一 继承 Thread 类 覆盖方法 run() 我们在创建的 Thread 类的子类中重写 run() 加入线程所要执行的代码即陵早可 下面是一个例子 public class MyThread extends Thread {int count= number;public MyThread(int num) {number = num;System out println( 创建线程 + number);}public void run() {while(true) {System out println( 线程 + number + :计数 + count);if(++count== ) return;}}public static void main(String args[]) {for(int i = ; i < 5; i++) new MyThread(i+1).start();}}这种方法简单明了，符合大家的习惯，但是，它也有一个很大的缺点，那就是如果我们的类已经从一个类继承（如小程序必须继承自 Applet 类），则无法再继承 Thread 类，这时如果我们又不想建立一个新的类，应该怎么办呢？我们不妨来探索一种新的方法：我们不创建 Thread 类的子类，而是直接使用它，那么我们只能将我们的方法作为参数传递给 Thread 类的实例，有点类似回调函数。.WINgWIT.但是 Java 没有指针，我们只能传递一个包含这个方法的类的实例。那么如何限制这个类必须包含这一方法呢？当然是使用接口！（虽然抽象类也可满足，但是需要继承，而我们之所以要采用这种新方法，不就是为了避免继承带来的限制吗？）Java 提供了接口 java.lang.Runnable 来支持这种方法。方法二：实现 Runnable 接口Runnable 接口只有一个方法 run()，我们声明自己的类实现 Runnable 接口并提供尺渣雀这一方法，将我们的线程代码写入其中，就完成了这一部分的任务。但是 Runnable 接口并没有任何对线程的支持，我们还必须创建 Thread 类的实例，这一点通过 Thread 类的构造函数public Thread(Runnable target);来实现。下面是一个例子：public class MyThread implements Runnable {int count= 1, number;public MyThread(int num) {number = num;System.out.println("创建线程 " + number);}public void run() {while(true) {System.out.println("线程 " + number + ":计数 " + count);if(++count== 6) return;} }public static void main(String args[]) {for(int i = 0; i < 5; i++) new Thread(new MyThread(i+1)).start();}}严格地说，创建 Thread 子类的实例也是可行的，但是必须注意的是，该子类必须没有覆盖 Thread 类的 run 方法，否则该线程执行的将是子类的 run 方法，而不是我们用以实现Runnable 接口的类的 run 方法，对此大家不妨试验一下。使用 Runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码，有利于封装，它的缺点在于，我们只能使用一套代码，若想创建多个线程并使各个线程执行不同的代码，则仍必须额外创建类，如果这样的话，在大多数情况下也许还不如直接用多个类分别继承 Thread 来得紧凑。综上所述，两种方法各有千秋，大家可以灵活运用。下面让我们一起来研究一下多线程使用中的一些问题。三：线程的四种状态1. 新状态：线程已被创建但尚未执行（start() 尚未被调用）。2. 可执行状态：线程可以执行，虽然不一定正在执行。CPU 时间随时可能被分配给该线程，从而使得它执行。3. 死亡状态：正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。4. 阻塞状态：线程不会被分配 CPU 时间，无法执行。四：线程的优先级 线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。你可以调用 Thread 类的方法 getPriority() 和 setPriority()来存取线程的优先级，线程的优先级界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之间，缺省是5(NORM_PRIORITY)。五：线程的同步由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：public synchronized void accessVal(int newVal);synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下： synchronized(syncObject) {//允许访问控制的代码}synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。六：线程的阻塞为了解决对共享存储区的访问冲突，Java 引入了同步机制，现在让我们来考察多个线程对共享资源的访问，显然同步机制已经不够了，因为在任意时刻所要求的资源不一定已经准备好了被访问，反过来，同一时刻准备好了的资源也可能不止一个。为了解决这种情况下的访问控制问题，Java 引入了对阻塞机制的支持。阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。1. sleep() 方法：sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。2. suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后 lishixin/Article/program/Java/gj/201311/27622
3. 多线程编程怎么回事啊
每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。进程也可能是整个程序或者是部分程序的动态执行。线程是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行。也可以把它理解为代码运行的上下文。所以线程基本上是轻量级的进程，它负责在单个程序里执行多任务。通常由操作系统负责多个线程的调度和执行。
什么是多线程？
多线程是为了使得多个线程并行的工作以完成多项任务，以提高系统的效率。线程是在同一时间需要完成多项任务的时候被实现的。
使用线程的好处有以下几点：
·使用线程可以把占据长时间的程序中的任务放到后台去处理
·用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度
·程序的运行速度可能加快
·在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。
还有其他很多使用多线程的好处，这里就不一一说明了。
一些线程模型的背景
我们可以重点讨论一下在Win32环境中常用的一些模型。
·单线程模型
在这种线程模型中，一个进程中只能有一个线程，剩下的进程必须等待当前的线程执行完。这种模型的缺点在于系统完成一个很小的任务都必须占用很长的时间。
·块线程模型（单线程多块模型STA）
这种模型里，一个程序里可能会包含多个执行的线程。在这里，每个线程被分为进程里一个单独的块。每个进程可以含有多个块，可以共享多个块中的数据。程序规定了每个块中线程的执行时间。所有的请求通过Windows消息队列进行串行化，这样保证了每个时刻只能访问一个块，因而只有一个单独的进程可以在某一个时刻得到执行。这种模型比单线程模型的好处在于，可以响应同一时刻的多个用户请求的任务而不只是单个用户请求。但它的性能还不是很好，因为它使用了串行化的线程模型，任务是一个接一个得到执行的。
·多线程块模型（自由线程块模型）
多线程块模型（MTA）在每个进程里只有一个块而不是多个块。这单个块控制着多个线程而不是单个线程。这里不需要消息队列，因为所有的线程都是相同的块的一个部分，并且可以共享。这样的程序比单线程模型和STA的执行速度都要块，因为降低了系统的负载，因而可以优化来减少系统idle的时间。这些应用程序一般比较复杂，因为程序员必须提供线程同步以保证线程不会并发的请求相同的资源，因而导致竞争情况的发生。这里有必要提供一个锁机制。但是这样也许会导致系统死锁的发生。
4. 谁知道多线程编程
主要内容：
1， 工作者线程
2， 用户界面线程
3， 同步
线程被分为工作者线程和用户用户界面线程。用户界面的线程的特点是拥有单独的消息队列，可以具有自己的窗口界面，能够对用户输入和事件作出反应。
可以用以下方法建立一个工作者线程。
UINT MyThreadProc(LPVOID pParam)
{
…
}
AfxBeginThread(MyThread,..);
它有六个参数，第一个为控制函数，第二个为启动线程时传给控制函数的入口参数，当前线程的优先级，当前线程的栈的大小，当前线程的创建状态，安全属性，后四个有默认值。
用户界面线程：
首先利用应用程序向导建立单文档程序Thread,再建立Thread1 : public CWinThread,
Frame1 : public CFrameWnd,可以用Ctrl+w建立这两个新类。
在CThreadApp中加一个指针Thread1* pThread1，在BOOL CThreadApp::InitInstance()
中进行初始化：
pThread1 = new Thread1();
pThread1->CreateThread();
将Thread1的构造函数改成公有。
在Thread1中加一个指针Frame1* m_pWnd，然后初始化。
BOOL Thread1::InitInstance()
{
m_pWnd = new Frame1();
return TRUE;
}
把Frame1的构造函数改成公有，在Thread.h中包含#include "Frame1.h"。
在资源编辑器中编辑一个菜单IDR_MENU，它有一个菜单项ID_BEGIN。
Frame1::Frame1()
{
Create(NULL,"Demo");
ShowWindow(SW_SHOW);
UpdateWindow();
CMenu menu;//可以用局部变量，因为以后不会用到它了,加菜单。
menu.LoadMenu(IDR_MENU);
SetMenu(&menu);
}
同步
多线程的一个难点是各线程间的协调。同样的方法在CThreadApp中再开一个线程。
BOOL CThreadApp::InitInstance()
{
。。。。。。
pThread1 = new Thread1();
pThread1->CreateThread();
pThread2 = new Thread1();
pThread2->CreateThread();
。。。。。。
}
为IDR_MENU中的菜单在Frame1中设立响应函数，方法也是Ctrl+w打开类向导。并在Frame1中定义一个全局整形变量n,初始值为0.
HANDLE handle=CreateSemaphore(NULL,0,1,"he");
WaitForSingleObject(handle,10000);
CString str;
n++;
str.Format("第%d次工作",n);
MessageBox(str);
ReleaseSemaphore(handle,1,NULL);
当你点击Frame1的菜单时，会弹出一个对话框，暂时不要点 确定，点击另一个线程的菜单，暂不会弹出对话框，确定刚才的对话框，另一个线程的对话框也弹出来了。
这个同步的方法称为信号量。它允许有限的线程存取某个共享的系统资源，采用计数器来实现信号量。
HANDLE CreateSemaphore(LPSECURITY_ATTRIBUTES lpa,LONG cSemInitial,LONG cSemMax,LPTSR lpszSemName);
第一个参数来指明所创建的对象是否可以被其子进程继承。如果你希望在所有的子进程之间共享这个信号量，可以把它的成员bInheritHandle设为true,也可以直接设为NULL来使用默认的安全设置第二个参数是还可以让几个线程使用，第三个参数是最多可以让几个线程使用。
最后参数是信号量的名字，在其它的进程中调用CreateSemapphore()或OpenSemaphore()时使用这个字符串作为参数之一就可以得到信号量的句柄。
ReleaseSemaphore(HANDLE hSemaphore, LONG cRelease,LPLONG plPrev)
5. Java多线程程序设计详细解析
一、理解多线程
多线程是这样一种机制，它允许在程序中并发执行多个指令流，每个指令流都称为一个线程，彼此间互相独立。
线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。
多个线程的执行是并发的，也就是在逻辑上“同时”，而不管是否是物理上的“同时”。如果系统只有一个CPU，那么真正的“同时”是不可能的，但是由于CPU的速度非常快，用户感觉不到其中的区别，因此我们也不用关心它，只需要设想各个线程是同时执行即可。
多线程和传统的单线程在程序设计上最大的区别在于，由于各个线程的控制流彼此独立，使得各个线程之间的代码是乱序执行的，由此带来的线程调度，同步等问题，将在以后探讨。
二、在Java中实现多线凯液慎程
我们不妨设想，为了创建一个新的线程，我们需要做些什么？很显然，我们必须指明这个线程所要执行的代码，而这就是在Java中实现多线程我们所需要做的一切！
真是神奇！Java是如何做到这一点的？通过类！作为一个完全面向对象的语言，Java提供了类java.lang.Thread来方便多线程编程，这个类提供了大量的方法来方便我们控制自己的各个线程，我们以后的讨论都将围绕这个类进行。
那么如何提供给 Java 我们要线程执行的代码呢？让我们来看一看 Thread 类。Thread 类最重要的方法是run()，它为Thread类的方法start()所调用，提供我们的线程所要执行的代码。为了指定我们自己的代码，只需要覆盖它！
方法一：继承 Thread 类，覆盖方法 run()，我们在创建的 Thread 类的子类中重写 run() ,加入线程所要执行的代码即可。下面是一个例子：
public class MyThread extends Thread
{
int count= 1, number;
public MyThread(int num)
{
number = num;
System.out.println
("创建线程 " + number);
}
public void run() {
while(true) {
System.out.println
("线程 " + number + ":计数 " + count);
if(++count== 6) return;
}
}
public static void main(String args[])
{
for(int i = 0;
i 〈 5; i++) new MyThread(i+1).start();
}
}
这种方法简单明了，符合大家的习惯，但是，它也有一个很大的缺点，那就是如果我们的类已经从一个类继承（如小程序必须继承自 Applet 类），则无法再继承 Thread 类，这时如果我们又不想建立一个新的类，应该怎么办呢？
我们不妨来探索一种新的方法：我们不创建Thread类的子类，而是直接使用它，那么我们只能将我们的方法作为参数传递给 Thread 类的实例，有点类似回调函数。但是 Java 没有指针，我们只能传递一个包含这个方法的类的实例。
那么如何限制这个类盯敬必须包含这一方法呢？当然是使用接口！（虽然抽象类也可满足，但是需要继承，而我们之所以要采用这种新方法，不就是为了避免继承带来的限制吗？）
Java 提供了接口 java.lang.Runnable 来支持这种方法。
方法二：实现 Runnable 接口
Runnable接口只有一个方法run()，我们声明自己的类实现Runnable接口并提供这一方法，将我们的线程代码写入其中，就完成了这一部分的任务。但是Runnable接口并没有任何对线程的支持，我们还必须创建Thread类的实例，这一点通过Thread类的构造函数public Thread(Runnable target);来实现。下面埋禅是一个例子：
public class MyThread implements Runnable
{
int count= 1, number;
public MyThread(int num)
{
number = num;
System.out.println("创建线程 " + number);
}
public void run()
{
while(true)
{
System.out.println
("线程 " + number + ":计数 " + count);
if(++count== 6) return;
}
}
public static void main(String args[])
{
for(int i = 0; i 〈 5;
i++) new Thread(new MyThread(i+1)).start();
}
}
严格地说，创建Thread子类的实例也是可行的，但是必须注意的是，该子类必须没有覆盖 Thread 类的 run 方法，否则该线程执行的将是子类的 run 方法，而不是我们用以实现Runnable 接口的类的 run 方法，对此大家不妨试验一下。
使用 Runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码，有利于封装，它的缺点在于，我们只能使用一套代码，若想创建多个线程并使各个线程执行不同的代码，则仍必须额外创建类，如果这样的话，在大多数情况下也许还不如直接用多个类分别继承 Thread 来得紧凑。
综上所述，两种方法各有千秋，大家可以灵活运用。
下面让我们一起来研究一下多线程使用中的一些问题。
三、线程的四种状态
1. 新状态：线程已被创建但尚未执行（start() 尚未被调用）。
2. 可执行状态：线程可以执行，虽然不一定正在执行。CPU 时间随时可能被分配给该线程，从而使得它执行。
3. 死亡状态：正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。
4. 阻塞状态：线程不会被分配 CPU 时间，无法执行。
四、线程的优先级
线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。
你可以调用 Thread 类的方法 getPriority() 和 setPriority()来存取线程的优先级，线程的优先级界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之间，缺省是5(NORM_PRIORITY)。
五、线程的同步
由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。
由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。
1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：
public synchronized void accessVal(int newVal);
synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。
这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。
在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。
synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。
2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：
synchronized(syncObject)
{
//允许访问控制的代码
}
#p#副标题#e#
synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。
六、线程的阻塞为了解决对共享存储区的访问冲突，Java 引入了同步机制，现在让我们来考察多个线程对共享资源的访问，显然同步机制已经不够了，因为在任意时刻所要求的资源不一定已经准备好了被访问，反过来，同一时刻准备好了的资源也可能不止一个。为了解决这种情况下的访问控制问题，Java 引入了对阻塞机制的支持。
阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。
1. sleep() 方法：sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。
2. suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。
3. yield() 方法：yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。
4. wait() 和 notify() 方法：两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许 指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用。
初看起来它们与 suspend() 和 resume() 方法对没有什么分别，但是事实上它们是截然不同的。区别的核心在于，前面叙述的所有方法，阻塞时都不会释放占用的锁（如果占用了的话），而这一对方法则相反。
上述的核心区别导致了一系列的细节上的区别。
首先，前面叙述的所有方法都隶属于 Thread 类，但是这一对却直接隶属于 Object 类，也就是说，所有对象都拥有这一对方法。初看起来这十分不可思议，但是实际上却是很自然的，因为这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的，调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放。
而调用 任意对象的notify()方法则导致因调用该对象的 wait() 方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。
其次，前面叙述的所有方法都可在任何位置调用，但是这一对方法却必须在 synchronized 方法或块中调用，理由也很简单，只有在synchronized 方法或块中当前线程才占有锁，才有锁可以释放。
同样的道理，调用这一对方法的对象上的锁必须为当前线程所拥有，这样才有锁可以释放。因此，这一对方法调用必须放置在这样的 synchronized 方法或块中，该方法或块的上锁对象就是调用这一对方法的对象。若不满足这一条件，则程序虽然仍能编译，但在运行时会出现IllegalMonitorStateException 异常。
wait() 和 notify() 方法的上述特性决定了它们经常和synchronized 方法或块一起使用，将它们和操作系统的进程间通信机制作一个比较就会发现它们的相似性：synchronized方法或块提供了类似于操作系统原语的功能，它们的执行不会受到多线程机制的干扰，而这一对方法则相当于 block 和wakeup 原语（这一对方法均声明为 synchronized）。
它们的结合使得我们可以实现操作系统上一系列精妙的进程间通信的算法（如信号量算法），并用于解决各种复杂的线程间通信问题。
关于 wait() 和 notify() 方法最后再说明两点：
第一：调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题。
第二：除了 notify()，还有一个方法 notifyAll() 也可起到类似作用，唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。
谈到阻塞，就不能不谈一谈死锁，略一分析就能发现，suspend() 方法和不指定超时期限的 wait() 方法的调用都可能产生死锁。遗憾的是，Java 并不在语言级别上支持死锁的避免，我们在编程中必须小心地避免死锁。
以上我们对 Java 中实现线程阻塞的各种方法作了一番分析，我们重点分析了 wait() 和 notify()方法，因为它们的功能最强大，使用也最灵活，但是这也导致了它们的效率较低，较容易出错。实际使用中我们应该灵活使用各种方法，以便更好地达到我们的目的。
七、守护线程
守护线程是一类特殊的线程，它和普通线程的区别在于它并不是应用程序的核心部分，当一个应用程序的所有非守护线程终止运行时，即使仍然有守护线程在运行，应用程序也将终止，反之，只要有一个非守护线程在运行，应用程序就不会终止。守护线程一般被用于在后台为其它线程提供服务。
可以通过调用方法 isDaemon() 来判断一个线程是否是守护线程，也可以调用方法 setDaemon() 来将一个线程设为守护线程。
八、线程组
线程组是一个 Java 特有的概念，在 Java 中，线程组是类ThreadGroup 的对象，每个线程都隶属于唯一一个线程组，这个线程组在线程创建时指定并在线程的整个生命期内都不能更改。
你可以通过调用包含 ThreadGroup 类型参数的 Thread 类构造函数来指定线程属的线程组，若没有指定，则线程缺省地隶属于名为 system 的系统线程组。
在 Java 中，除了预建的系统线程组外，所有线程组都必须显式创建。在 Java 中，除系统线程组外的每个线程组又隶属于另一个线程组，你可以在创建线程组时指定其所隶属的线程组，若没有指定，则缺省地隶属于系统线程组。这样，所有线程组组成了一棵以系统线程组为根的树。
Java 允许我们对一个线程组中的所有线程同时进行操作，比如我们可以通过调用线程组的相应方法来设置其中所有线程的优先级，也可以启动或阻塞其中的所有线程。
Java 的线程组机制的另一个重要作用是线程安全。线程组机制允许我们通过分组来区分有不同安全特性的线程，对不同组的线程进行不同的处理，还可以通过线程组的分层结构来支持不对等安全措施的采用。
Java 的 ThreadGroup 类提供了大量的方法来方便我们对线程组树中的每一个线程组以及线程组中的每一个线程进行操作。
九、总结
在本文中，我们讲述了 Java 多线程编程的方方面面，包括创建线程，以及对多个线程进行调度、管理。我们深刻认识到了多线程编程的复杂性，以及线程切换开销带来的多线程程序的低效性，这也促使我们认真地思考一个问题：我们是否需要多线程？何时需要多线程？
多线程的核心在于多个代码块并发执行，本质特点在于各代码块之间的代码是乱序执行的。我们的程序是否需要多线程，就是要看这是否也是它的内在特点。
假如我们的程序根本不要求多个代码块并发执行，那自然不需要使用多线程；假如我们的程序虽然要求多个代码块并发执行，但是却不要求乱序，则我们完全可以用一个循环来简单高效地实现，也不需要使用多线程；只有当它完全符合多线程的特点时，多线程机制对线程间通信和线程管理的强大支持才能有用武之地，这时使用多线程才是值得的。
#p#副标题#e#
6. 如何用c++builder 编写多线程
摘 要：本文简单介绍了Windows环境下进行多线程编程的意义，重点讨论了C++Builder环境下开发多线程应用程序这一问题，并通过实现生产者－消费者问题，帮我们更好地理解同步概念及其实现方法。
关键词：多线程；同步；生产者－消费者；C++Builder
线程之可行性
在很多情况下，可能需要为程序创建线程。这里给出其中一些可能性：
(1)如果创建的是一个多文档接口（Multiple Document Interface,MDI）程序，那么为每个窗口分配一个线程就显得十分重要了，例如，对于一个通过多个Modem同时连接到多个主机的MDI通信程序而言，如果每个窗口都有它自己的线程来和一个主机通信，那么整个事情就简化很多。
(2)如果使用的是一台有多个处理器的机器，并希望充分利用所有可能获得的CPU资源，那么就需要将应用程序分解成多个线程。Windows2000中CPU的划分单位为线程。因此，如果程序只包含一个线程，那么，默认环境下该程序只能使用其中一个CPU。但是，如果将此程序划分为多个线程，那么Windows2000就可以在不同的CPU上运行各个线程。
(3)在后台运行的某些任务的同时，要求用户还可以继续使用应用程序进行工作。利用线程很容易实现这点。例如：可以将一些冗长的重算、页面格式化操作、文件的读写等活动都放在单独的线程中，使其在后台运行，而不会对用户造成影响。
同步
撰写多线程程序的一个最具挑战性的问题就是：如何让一个线程和另一个线程合作。这引出了一个非常重要的问题：同步。所谓同步是指进程、线程间相互通信时避免破坏各自数据的能力。Windows环境下的同步问题是由Win32系统的CPU时间片分配方式引起的。虽然在某一时刻，只有一个线程占用CPU（单CPU）时间，但是无法知道在什么时候，在什么地方线程被打断，这样如何保证线程之间不破坏彼此的数据就显得格外重要。同步问题是如此重要，也相当有趣，因而吸引了不少学者对他进行研究，由此产成了一系列经典的进程同步问题，其中较有代表性的是"生产者－消费者问题"、"读者－写者问题""哲学家进餐问题"等。在此，本文简要讨论了C++Builder平台下如何利用多线程编程技术实现"生产者－消费者"问题，帮助我们更好得理解同步概念及其实现方法。
生产者－消费者问题
生产者－消费者问题是一个著名的进程同步问题。它描述的是：有一群生产者进程在生产消息，并将此消息提供给消费者进程去消费。为使生产者进程和消费者进程能并发进行，在他们之间设置了一个具有N个缓冲区的缓冲池，生产者进程可以将它所生产的消息放入一个缓冲区中，消费者进程可以从一个缓冲区中取得一个消息消费。尽管所有的生产者进程和消费者进程都是以异步方式进行的，但他们之间必须保持同步，即不允许消费者进程到一个空的缓冲区中去取消息，也不允许生产者进程向一个已装满消息且尚未被取走消息的缓冲区中投放消息。
C++Builder多线程应用程序编程基础
1、使用C++Builder提供的TThread类
VCL类库提供了用于线程编程的TThread类。在TThread类中封装了Windows中关于线程机制的WindowsAPI。对于大多数的应用程序来说，可在应用程序中使用线程对象来表示执行线程。线程对象通过封装使用线程所需的内容，简化了多线程应用程序的编写。注意，线程对象不允许控制线程堆栈的大小或其安全属性。若需要控制这些，必须使用WindowsAPI的Create Thread()或Begin Thread()函数。
TThread类有以下一些属性和方法：
1) 属性：
·Priority：优先级属性。可以设置线程的优先级。
·Return Value：返回值属性。当线程介绍时返回给其他线程一个数值。
·Suspended：挂起属性。可以判断线程是否被挂起。
·Terminated：结束属性。用来标志是否应该结束线程。
·ThreadID：标识号属性。在整个系统中线程的标识号。使用Windows API函数时该属性非常有用。
2） 方法：
·Do Terminate：产生一个On Terminate事件，但是不结束线程的执行。
·Resume：唤醒一个线程继续执行。
·Suspend：挂起一个线程，要与Resume过程成对使用。
·Synchronize：由主VCL线程调用的一个同步过程。
·Terminate：将Terminate属性设置为True，中止线程的执行。
·Wait For：等待线程的中止并返回Return Value属性的数值。
2、协调线程
在编写线程执行时运行的代码时，必须考虑到可能同步执行的其他线程的行为。特别注意，避免两个线程试图同时使用相同的全局对象或变量。另外，一个线程中的代码会依赖其他线程执行任务的结果。
1） 避免同时访问
为避免在访问全局对象或变量时与其他线程发生冲突，可能需要暂停其他线程的执行，直到该线程代码完成操作。
(1)锁定对象。一些对象内置了锁定功能，以防止其他线程使用该对象的实例。例如，画布对象（TCanvas及其派生类）有一种Lock（）函数可以防止其他线程访问画布，直到调用Unlock（）函数。显然，这种方法只对部分类有效。
(2)使用重要区段。若对象没有提供内置的锁定功能，可使用重要区段。重要区段像门一样，每次只允许一个线程进入，要使用重要区段，需创建TCriticalSection的全局实例。TCriticalSection有两个函数：Acquire（）（阻止其他线程执行该区域）及Release（）（取消对其他线程的阻止）。
(3)使用多重读、独占写的同步器。当使用重要区段来保护全局内存时，每次只有一个线程可以使用该内存。这种保护可能会超出了需要，特别是有一个经常读但很少写的对象或变量时更是如此。多个线程同时读相同内存但没有线程写内存是没有危险的。当有一些经常被读,但是很少写的全局变量时，可用对象保护它。这个对象和重要区段一样，但它允许多个线程同时读，只要没有线程写即可。每个需要读内存的线程首先要调用Begin Read（）函数（确保当前无其他线程写内存），线程完成对保护内存读操作后，要调用End Read（）函数。任何线程需要写保护内存必须调用Begin Write（）函数（确保当前无其他线程读或写内存），完成对保护内存写操作后，调用End Write（）函数。
(4)使用Synchronize函数:Void __fast call Synchronize (TThreadMethod &Method);
其中参数Method为一个不带参数的过程名。在这个不带参数的过程中是一些访问VCL的代码。我们可以在Execute过程中调用Synchronize过程来避免对VCL的并发访问。程序运行期间的具体过程实际上是由Synchronize过程来通知主线程，然后主线程在适当的时机来执行Synchronize过程的参数列表中的那个不带参数的过程。在多个线程的情况下，主线程将Synchronize过程发过来的通知放到消息队列中，然后逐个地响应这些消息。通过这种机制Synchronize实现了线程之间地同步。
2) 等待其他线程
若线程必须等待另一线程完成某项任务，可让线程临时中断执行。然后，要么等待另一线程完全执行结束，要么等待另一线程通知完成了该任务。
(1)等待线程执行结束
要等待另一线程执行结束，使用它地Wait For（）函数。Wait For函数直到那个线程终止才返回，终止的方式要么完成了其Execute（）函数，要么由于一个异常。
(2)等待任务完成。有时，只需要等待线程完成一些操作而不是等待线程执行结束。为此，可使用一个事件对象。事件对象（TEvent）应具有全局范围以便他们能够为所有线程可见。当一个线程完成一个被其他线程依赖的操作时，调用TEvent：：Set Event（）函数。Set Event发出一个信号，以便其他线程可以检查并得知操作完成。要关掉信号，则使用Reset Event()函数。
例如，当必须等待若干线程完成其执行而不是单个线程时。因为不知道哪个线程最后完成，也就不能对某个线程使用Wait For（）函数。此时，可通过调用Set Event以在线程结束时累加计数值并在最后一个线程结束时发出信号以指示所有线程结束。
多线程应用程序编程实例
下面是一个实现"生产者－消费者问题"的多线程应用实例。在此例中，我们按上面介绍的方法构造了两个TThread的子类TProcerThread（生产者线程）和TCustomerThread（消费者线程），生产和消费的商品仅仅是一个整数。在协调生产和消费的过程中，重要区段（TCriticalSection）和事件（TEvent）得到了应用。生产者通过TEvent类的对象Begin Consume来通知消费者开始消费，而消费者通过TEent类的对象Begin Proce通知生产者开始生产。程序中共有两个生产者，一个消费者。在两个生产者之间，通过TCriticalSection类的对象同步。其运行界面如图1所示。
图1 程序运行效果
主要源程序如下所示：
生产者线程：
Void __fast call TProcerThread:: Execute ()
{
//---- Place thread code here ----
Int i = 0;
Int j;
while(i<100) //每个生产者线程生产100个商品
{
Sleep(1000);//延迟，为清楚得显示执行效果
if(Form1->buffer_size > 0)//缓冲池不空，通知消费者消费
{
Form1->Begin Consumer->Set Event ();
}
Form1->Proce Guard->Acquire ();
i++;
StrResult = IntToStr (i);
J = Form1->buffer_size;
Form1->Proct [j] = i;
Form1->buffer_size++;
Synchron
转载，仅供参考，祝你愉快，满意请采纳。
7. 关于C++多线程编程教学
在Windows NT和Windows 9x中，多线程的编程实现需要调用一系列的API函数，如CreateThread、ResumeThread等，比较麻烦而且容易出错。我们使用Inprise公司的新一代RAD开发工具C＋＋Builder，可以方便地实现多线程的编程。与老牌RAD工具Visual Basic和Delphi比，C＋＋Builer不仅功能非常强大，而且它的编程语言是C＋＋，对于系统开发语言是C的Windows系列操作系统，它具有其它编程语言无可比拟的优势。利用C＋＋Builder提供的TThread对象，多线程的编程变得非常简便易用。那么，如何实现呢？且待我慢慢道来，让你体会一下多线程樱配的强大功能。
1. 创建多线程程序：
首先，先介绍一下实现多线程的具体步骤。在C＋＋Builder中虽然用Tthread对象说明了线程的概念，但是Tthread对象本身并不完整，需要在TThread下新建其子类，并重载Execute方法来使用线程对象。在C＋＋Builder下可以很方便地实现这一点。
在C＋＋Builder IDE环境下选择菜单File|New，在肆李New栏中选中Thread Object，按OK，接下来弹出输入框，输入TThread对象子类的名字MyThread，这样C＋＋Builder自动为你创建了一个名为TMyThread的TThread子类。同时编辑器中多了一个名为Unit2.cpp的单元,这就是我们创建的TMyThread子类脊雹指的原码，如下：
＃include
＃pragma hdrstop
＃include “Unit2.h”
＃pragma package(smart_init)
//－－－－－－－－－－－－－－－－－－－－－
// Important: Methods and properties of objects in VCL can only be
// used in a method called using Synchronize, for example:
//
// Synchronize(UpdateCaption);
//
// where UpdateCaption could look like:
//
// void __fastcall MyThread::UpdateCaption()
// {
// Form1－>Caption = “Updated in a thread”;
// }
//－－－－－－－－－－－－－－－－－－－－
__fastcall MyThread::MyThread(bool CreateSuspended)
: TThread(CreateSuspended)
{
}
//－－－－－－－－－－－－－－－－－－－－
void __fastcall MyThread::Execute()
{
//－－－－ Place thread code here －－－－
}
//－－－－－－－－－－－－－－－－－－－－－
其中的Execute（）函数就是我们要在线程中实现的任务的代码所在处。在原代码中包含Unit2.cpp，这个由我们创建的TMyThread对象就可以使用了。使用时，动态创建一个TMyThread 对象，在构造函数中使用Resume（）方法，那么程序中就增加了一个新的我们自己定义的线程TMyThread，具体执行的代码就是Execute（）方法重载的代码。要加载更多的线程，没关系，只要继续创建需要数量的TMyThread 对象就成。
8. 多线程的java 程序如何编写
Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
9. Java多线程程序设计初步入门
在Java语言产生前 传统的程序设计语言的程序同一时刻只能单任务操作 效率非常低 例如程序往往在接收数据输入时发生阻塞 只有等到程序获得数据后才能继续运行 随着Internet的迅猛发展 这种状况越来越不能让人们忍受 如果网络接收数据阻塞 后台程序就处于等待状态而不继续任何操作 而这种阻塞是经常会碰到的 此时CPU资源被白白的闲置起来 如果在后台程序中能够同时处理多个任务 该多好啊！应Internet技术而生的Java语言解决了这个问题 多线程程序是Java语言的一个很重要的特点 在一个Java程序中 我们可以同时并行运行多个相对独立的线程 例如 我们如果创建一个线程来进行数据输入输出 而创建另一个线程在后台进行其它的数据处理 如果输入输出线程在接收数据时阻塞 而处理数据的线程仍然在运行 多线程程序设计大大提高了程序执行效率和处理能力
线程的创建
我们知道Java是面向对象的程序语言 用Java进行程序设计就是设计和使用类 Java为我们提供了线程类Thread来创建线程 创建线程与创建普通闹梁的类的对象的操作是一样的 而线程就是Thread类或其子类的实例对象 下面是一个创建启动一个线程的语句
Thread thread =new Thread(); file://声明困弯神一个对象实例 即创建一个线程
Thread run(); file://用Thread类中的run()方法启动线程
从这个例子 我们可以通过Thread（）构造方法创建一个线程 并启动该线程 事实上 启动线程 也就是启动线程的run（）方法 而Thread类中的run（）方法没有任何操作语句 所以这个线程没有任何操作 要使线程实现预定功能 必须定义自己的run（）方法 Java中通常有两种方式定义run（）方法
通过定义一个Thread类的子类 在该子类中重写run（）方法 Thread子类的实例对象就是一个线程 显然 该线程汪亏有我们自己设计的线程体run（）方法 启动线程就启动了子类中重写的run（）方法
通过Runnable接口 在该接口中定义run（）方法的接口 所谓接口跟类非常类似 主要用来实现特殊功能 如复杂关系的多重继承功能 在此 我们定义一个实现Runnable（） 接口的类 在该类中定义自己的run（）方法 然后以该类的实例对象为参数调用Thread类的构造方法来创建一个线程
线程被实际创建后处于待命状态 激活（启动）线程就是启动线程的run（）方法 这是通过调用线程的start（）方法来实现的
下面一个例子实践了如何通过上述两种方法创建线程并启动它们
// 通过Thread类的子类创建的线程 class thread extends Thread { file://自定义线程的run()方法 public void run() { System out println( Thread is running… ); } } file://通过Runnable接口创建的另外一个线程 class thread implements Runnable { file://自定义线程的run()方法 public void run() { System out println( Thread is running… ); } } file://程序的主类 class Multi_Thread file://声明主类 { plubic static void mail(String args[]) file://声明主方法 { thread threadone=new thread (); file://用Thread类的子类创建线程 Thread threado=new Thread(new thread ()); file://用Runnable接口类的对象创建线程 threadone start(); threado start(); file://strat()方法启动线程 } }
运行该程序就可以看出 线程threadone和threado交替占用CPU 处于并行运行状态 可以看出 启动线程的run()方法是通过调用线程的start()方法来实现的(见上例中主类) 调用start()方法启动线程的run()方法不同于一般的调用方法 调用一般方法时 必须等到一般方法执行完毕才能够返回start()方法 而启动线程的run()方法后 start()告诉系统该线程准备就绪可以启动run()方法后 就返回start()方法执行调用start()方法语句下面的语句 这时run()方法可能还在运行 这样 线程的启动和运行并行进行 实现了多任务操作
线程的优先级
对于多线程程序 每个线程的重要程度是不尽相同 如多个线程在等待获得CPU时间时 往往我们需要优先级高的线程优先抢占到CPU时间得以执行 又如多个线程交替执行时 优先级决定了级别高的线程得到CPU的次数多一些且时间多长一些 这样 高优先级的线程处理的任务效率就高一些
Java中线程的优先级从低到高以整数 ~ 表示 共分为 级 设置优先级是通过调用线程对象的setPriority()方法 如上例中 设置优先级的语句为
thread threadone=new thread (); file://用Thread类的子类创建线程
Thread threado=new Thread(new thread ()); file://用Runnable接口类的对象创建线程
threadone setPriority( ); file://设置threadone的优先级
threado setPriority( ); file://设置threado的优先级
threadone start(); threado start(); file://strat()方法启动线程
这样 线程threadone将会优先于线程threado执行 并将占有更多的CPU时间 该例中 优先级设置放在线程启动前 也可以在启动后进行设置 以满足不同的优先级需求
线程的（同步）控制
一个Java程序的多线程之间可以共享数据 当线程以异步方式访问共享数据时 有时候是不安全的或者不和逻辑的 比如 同一时刻一个线程在读取数据 另外一个线程在处理数据 当处理数据的线程没有等到读取数据的线程读取完毕就去处理数据 必然得到错误的处理结果 这和我们前面提到的读取数据和处理数据并行多任务并不矛盾 这儿指的是处理数据的线程不能处理当前还没有读取结束的数据 但是可以处理其它的数据
如果我们采用多线程同步控制机制 等到第一个线程读取完数据 第二个线程才能处理该数据 就会避免错误 可见 线程同步是多线程编程的一个相当重要的技术
在讲线程的同步控制前我们需要交代如下概念
用Java关键字synchonized同步对共享数据操作的方法
在一个对象中 用synchonized声明的方法为同步方法 Java中有一个同步模型 监视器 负责管理线程对对象中的同步方法的访问 它的原理是 赋予该对象唯一一把 钥匙 当多个线程进入对象 只有取得该对象钥匙的线程才可以访问同步方法 其它线程在该对象中等待 直到该线程用wait（）方法放弃这把钥匙 其它等待的线程抢占该钥匙 抢占到钥匙的线程后才可得以执行 而没有取得钥匙的线程仍被阻塞在该对象中等待
file://声明同步的一种方式 将方法声明同步
class store {public synchonized void store_in(){… }public synchonized void store_out(){ … }}
利用wait（） notify（）及notifyAll（）方法发送消息实现线程间的相互联系
Java程序中多个线程通过消息来实现互动联系的 这几种方法实现了线程间的消息发送 例如定义一个对象的synchonized 方法 同一时刻只能够有一个线程访问该对象中的同步方法 其它线程被阻塞 通常可以用notify（）或notifyAll（）方法唤醒其它一个或所有线程 而使用wait（）方法来使该线程处于阻塞状态 等待其它的线程用notify（）唤醒
一个实际的例子就是生产和销售 生产单元将产品生产出来放在仓库中 销售单元则从仓库中提走产品 在这个过程中 销售单元必须在仓库中有产品时才能提货 如果仓库中没有产品 则销售单元必须等待
程序中 假如我们定义一个仓库类store 该类的实例对象就相当于仓库 在store类中定义两个成员方法 store_in（） 用来模拟产品制造者往仓库中添加产品 strore_out（）方法则用来模拟销售者从仓库中取走产品 然后定义两个线程类 customer类 其中的run（）方法通过调用仓库类中的store_out（）从仓库中取走产品 模拟销售者 另外一个线程类procer中的run（）方法通过调用仓库类中的store_in（）方法向仓库添加产品 模拟产品制造者 在主类中创建并启动线程 实现向仓库中添加产品或取走产品
如果仓库类中的store_in（） 和store_out（）方法不声明同步 这就是个一般的多线程 我们知道 一个程序中的多线程是交替执行的 运行也是无序的 这样 就可能存在这样的问题
仓库中没有产品了 销售者还在不断光顾 而且还不停的在 取 产品 这在现实中是不可思义的 在程序中就表现为负值 如果将仓库类中的stroe_in（）和store_out（）方法声明同步 如上例所示 就控制了同一时刻只能有一个线程访问仓库对象中的同步方法 即一个生产类线程访问被声明为同步的store_in（）方法时 其它线程将不能够访问对象中的store_out（）同步方法 当然也不能访问store_in（）方法 必须等到该线程调用wait（）方法放弃钥匙 其它线程才有机会访问同步方法
lishixin/Article/program/Java/gj/201311/27301
10. 关于Java多线程的（高手请帮忙）
package First;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import com.sun.media.sound.Toolkit;
public class test {
static int num = 0;
public static void main(String[] args) {
System.out.println("now:" + num );
new test().start();
}
class Thd implements Runnable{//创建线程
public void run() {
num ++;
System.out.println( num + "\n");
}
}
class Thd1 implements Runnable{//创建线程
public void run() {
num --;
System.out.println( num + "\n");
}
}
public void start() {
for ( int i = 0;i < 2; i ++){
Thd th1 = new Thd();
new Thread(th1).start();//线程启动
}
for ( int i = 0;i < 2; i ++){
Thd1 th = new Thd1();
new Thread(th).start();//线程启动
}
}
}