Java学习之多线程

程序、进程和线程

程序是计算机指令的集合，它以文件的形式存储在磁盘上。

进程：是一个程序在其自身的地址空间中的一次执行活动。

进程是资源申请、调度和独立运行的单位，因此，它使用系统中的运行资源；而程序不能申请系统资源，不能被系统调度，也不能作为独立运行的单位，因此，它不占用系统的运行资源。

线程：是进程中的一个单一的连续控制流程。一个进程可以拥有多个线程。

线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。

Java
在语言级提供了对多线程程序设计的支持。

实现多线程程序的两种方式：

（
1
）从
Thread
类继承；

（
2
）实现
Runnable
接口

Java
运行时系统实现了一个用于调度线程执行的线程调度器，用于确定某一时刻由哪一个线程在
CPU
上运行。

在
java
技术中，线程通常是抢占式的而不需要时间片分配进程（分配给每个线程相等的
CPU
时间的进程）。抢占式调度模型就是许多线程处于可以运行状态（等待状态），但实际上只有一个线程在运行。该线程一直运行到它终止进入可运行状态（等待状态），或者另一个具有更高优先级的线程变成可运行状态。在后一种情况下，低优先级的线程被高优先级的线程抢占，高优先级的线程获得运行的机会。

Java
线程调度器支持不同优先级线程的抢先方式，但其本身不支持相同优先级线程的时间片轮换。

Java
运行时系统所在的操作系统（例如：
Windows2000
）支持时间片的轮换，则线程调度器就支持相同优先级线程的时间片轮换。

每一个对象除了有一个锁之外，还有一个等待队列（
wait set
），当一个对象刚创建的时候，它的对待队列是空的。

我们应该在当前线程锁住对象的锁后，去调用该对象的
wait
方法。

当调用对象的
notify
方法时，将从该对象的等待队列中删除一个任意选择的线程，这个线程将再次成为可运行的线程。

当调用对象的
notifyAll
方法时，将从该对象的等待队列中删除所有等待的线程，这些线程将成为可运行的线程。

wait
和
notify
主要用于
producer-consumer
这种关系中。

-----------------------------------------------
从
Thread
类继承
-------------------------------------------------

public


class

ThreadTest {
//
多线程

/**

*

@param


args

*/

public


static


void

main(String args[]){

MyThread mt=
new

MyThread();

//
mt.setDaemon(true);

//
mt.setPriority(Thread.MAX_PRIORITY);

//
mt.start();

//
new Thread(mt).start();

mt.getThread().start();

mt.getThread().start();

mt.getThread().start();

mt.getThread().start();

mt.getThread().start();

int

num=0;

while

(
true

)

{

if

(num++==100){

break

;

}

System.
out

.println(
"main:"
+Thread.currentThread
().getName()+
"
"
+num);

}

/*System.out.println(mt.MIN_PRIORITY);

System.out.println(mt.NORM_PRIORITY);

System.out.println(mt.MAX_PRIORITY);*/

}

}

class

MyThread{
//implements
Runnable//extends Thread{

private


class

InnerThread
extends

Thread{

int


num
=0;

public


void

run(){

while

(
true

){

if

(
num
++==100){

break

;

}

System.
out

.println(Thread.currentThread
().getName()+
"
"
+
num
);

}

}

}

public

Thread getThread(){

return


new

InnerThread();

}

/*public void run(){

while(true){

System.out.println(getName());

yield();

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

}

}*/

}

--------------------------------------------------
实现
Runnable
接口
-------------------------------------------

public class RunnableThreadTest implements
Runnable{

int
count;

Thread
th;

/*String
ThreadName;*/

RunnableThreadTest(String
name){

th=new
Thread(this,name);

th.start();

}

public
void run() {

//
TODO Auto-generated method stub

System.out.println(th.getName()+"

时间片轮转
");

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

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

try
{

Thread.sleep(500);

}

catch
(InterruptedException e) {

}

System.out.println("
线程
# "+th.getName()+"
开始工作
,"+"count="+count);

count++;

}

}

}

class UseRunnableThreads{

public
static void main(String args[]){

System.out.println("The
main Thread is starting");

RunnableThreadTest
t1=new RunnableThreadTest("1");

RunnableThreadTest
t2=new RunnableThreadTest("2");

RunnableThreadTest
t3=new RunnableThreadTest("3");

/*while(t1.th.isAlive()||t2.th.isAlive()||t3.th.isAlive()){

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

try
{

Thread.sleep(100);

}
catch (InterruptedException e) {

e.printStackTrace();

}

}*/

try
{

t1.th.join();

System.out.println("
线程
1 joined");

t2.th.join();

System.out.println("
线程
2 joined");

t3.th.join();

System.out.println("
线程
3 joined");

}
catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("Main
Thread is End");

/*Test2
t=new Test2("1");

t.start();*/

}

}