lzg

2308 积分	0 好友	259 主题

发消息

Java线程详解

楼主

发表于 2015-4-22 22:48:55 | 查看: 1000| 回复: 0

程序本身是一个静态的概念，而进程是程序的一次执行过程，每一个进程都有自己的地址空间。线程实际上是在进程的基础之上的进一步划分。一个进程至少对应一个线程，线程之间共享一个内存空间，线程之间可以相互切换，并发执行。

一.线程的实现

java中实现线程有两种方式：

1.继承Thread类

2.实现Runnable接口（这种方式用得比较多）

继承Thread类实现代码：

Java代码 [url=][/url]

public class Test {
public static void main(String[] args){
myThread thread=new myThread();
//不是马上执行线程，而是把线程置于就绪状态，等待CPU调用
thread.start();
}
}
//继承Thread类
class myThread extends Thread{
@Override
public void run() {
int i=0;
while(true)
{
if(i>10)
break;
System.out.println(i);
i++;
}
}
}

实现Runnable接口代码：

Java代码 [url=][/url]

public class Test {
public static void main(String[] args){
myRunnable runnable=new myRunnable();
Thread thread=new Thread(runnable);
//不是马上执行线程，而是把线程置于就绪状态，等待CPU调用
thread.start();
}
}
//继承Thread类
class myRunnable implements Runnable{
public void run() {
int i=0;
while(true)
{
if(i>10)
break;
System.out.println(i);
i++;
}
}
}

Runnale是实现run方法,Thread是重写run方法,run方法是Runnable接口的一个抽象方法,Thread类已经实现了该接口。

run方法执行完线程会正常结束

二.线程主要方法

1.sleep方法

让当前线程进入休眠状态，让出当前执行CPU的时间，该线程不会丢失任何监视器的所属权，调用方法为Thread.sleep(1000)//休眠一秒。sleep方法休眠完成后，线程会进入就绪状态，参与CPU的争抢。

有时会看到线程调用sleep(0)，表示释放cpu时间，马上回到就绪状态争抢cpu使用权。sleep(0)可以释放当前线程执行完所剩的时间(如果有剩余的话)。这样可以让去其他线程得到执行，不会浪费所剩下的时间。提高效率。

示例代码：

Java代码 [url=][/url]

class myRunnable implements Runnable {
public void run() {
int i = 0;
try {
while (true) {
if (i > 10)
break;
System.out.println(i);
i++;
Thread.sleep(1000);//休眠一秒
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

2.join方法

把指定线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行。如，在线程1中调用了线程2的join()方法，直到线程2执行完，才会继续执行线程1。

join方法调用形式：

1.join() //直到调用线程执行结束

2.join(int millis) //等待调用线程指定时间

示例代码：

Java代码 [url=][/url]

public class Test {
public static void main(String[] args) {
myRunnable runnable = new myRunnable();
Thread thread = new Thread(runnable);
// 不是马上执行线程，而是把线程置于就绪状态，等待CPU调用
thread.start();
for (int i = 0; i < 9; i++) {
try {
if (i == 4)
thread.join();//会等待子线程执行完毕在继续执行
System.out.println("主线程: "+i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//继承Thread类
class myRunnable implements Runnable {
public void run() {
int i = 0;
try {
while (true) {
if (i > 10)
break;
System.out.println("子线程: "+i);
i++;
Thread.sleep(1000);//休眠一秒
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

3.interrupt方法

中断线程。其实真正中断线程是线程内部自己实现的，可以把interrupt理解为一个中断标记，告诉线程内部实现中断，当然有可能会中断失败。如果在调用interrupt方法打上中断标记后，又调用了wait()，join()，sleep()方法，此时会清除interrupt的中断标记，并抛出InterruptedException异常。

其实不推荐使用interrupt方法来中断线程，建议使用自己定义的标记来中断线程。

如：

Java代码 [url=][/url]

// 继承Thread类
class myRunnable implements Runnable {
private boolean flag=true;//线程标记
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
public void run() {
while(flag){
int i = 0;
try {
while (true) {
System.out.println("子线程: "+i);
i++;
Thread.sleep(1000);//休眠一秒
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

当需要终止线程时，调用setFlag(false)就可以了。此时run方法将会执行完毕，线程正常结束。

4.yield()方法

让出此次cpu的执行权力，直接进入就绪状态,等待争抢下一次CPU使用权

yield()和sleep()的区别：

1.sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

2.sleep()可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会；而yield()方法只会给相同优先级或者更高优先级的线程一个运行的机会。

三.线程的同步和死锁

在多个线程操作中，多个线程可能要同时处理一个资源，此时就必须使用到同步。所谓的同步就是指在一个时间段内只能有一个线程执行指定代码，其他线程要等待此线程完成后才能执行。

当多个线程同时读写同一份共享资源的时候，可能会引起冲突。这时候，我们需要引入线程“同步”机制，即各位线程之间要有个先来后到，不能一窝蜂挤上去抢作一团。
线程同步的真实意思和字面意思恰好相反。线程同步的真实意思，其实是“排队”：几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作。

线程实现同步有两种方法：

1.同步代码块

synchronized(同步标记){

要同步的代码

}

如：

Java代码 [url=][/url]

public class Test {
public static void main(String[] args) {
myRunnable runnable = new myRunnable();
//公用一份
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
// 不是马上执行线程，而是把线程置于就绪状态，等待CPU调用
thread1.start();
thread2.start();
}
}
// 继承Thread类
class myRunnable implements Runnable {
Object obj=new Object();//同步标记
public void run() {
synchronized(obj){
int i = 0;
try {
while (true) {
if(i==5)
break;
System.out.println("子线程: " + i);
i++;
Thread.sleep(1000);// 休眠一秒
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

解释：若先thread1执行代码块，此时thread1会打上标记，可以理解为锁上门，当本次事件用完thread1还没执行完同步代码块；下一次thread2抢得cpu执行权，要执行此同步代码块，然而代码块被thread1上了锁，即打上了标记；此时thread2进不去，只能在门外干等把此次cpu事件消耗完。下一次若thread1抢得cpu执行权，本次thread1执行完代码块，即消除标记，打开门上的锁，下次若thread2抢得cpu执行权，则打上thread2的标记，执行同步代码块。

2.同步方法

public synchronized void method()

{
}

如：

Java代码 [url=][/url]