J2SE快速进阶——Java多线程机制

标签：

       学习Java中的线程时，自然而然地联想到之前学过的操作系统中处理器那一块的知识。

       定义

       文章开头，先大概说一下程序、进程和线程的概念及其之间的关系。

       程序：程序就是一段静态的代码，或者一个可执行程序。

       进程：进程是程序的一次动态执行的过程，它对应着从代码加载、运行到结束的一次动态的执行过程。

       线程：比进程更小的执行单位，一个进程在执行过程中，可以产生多个线程，也就是多个分支。它是程序执行流的最小单位。

       来看一个小程序：

public class Test {
	public static void main(String[] args) {
		fun1();
	}
	public static void fun1(){
		System.out.println(fun2()+fun3());		
	}
	public static String fun2(){
		return "Hello ";
	}
	public static String fun3(){
		return "World!";
	}
}

          它的执行顺序如下，在main方法中，从①执行到⑥是一条线，并没有分支，这就是一个线程。

        线程的实现

        当JVM执行到main方法时，就会启动一个线程，叫做主线程。如果main方法中还创建了其他线程，那么JVM就会在主线程和其他线程之间轮流切换，保证每个线程都有机会使用CPU资源。

       Java中的线程是通过java.lang.Thread类来实现的，每一个Thread对象都代表一个新的线程。

       Java中实现线程有两种方法：

       1、继承Thread类，并且重写其run方法（用来封装整个线程要执行的命令），调用start方法启动线程。

       比如下面这个类T要实现线程，则代码如下：

public class CreateThreadTest{
	public static void main(String[] args) {
		T r=new T();
		r.start();   //T类的线程开始执行
		for(int i=0;i<100;i++)
		{
			System.out.println("主线程正在执行~~~~"+i);
		}
	}
}
class T extends Thread
{
	public void run(){//重写父类中的run方法
		for(int i=0;i<100;i++)
		{
			System.out.println("我创建的线程正在执行~~~~"+i);
		}
	}
}

        2、实现Runnable接口

        还有一种方法就是让实现线程的类实现Runnable接口，实现Runnable接口中唯一的方法run()，然后把此类的实例当做Thread类的构造函数的参数，创建线程对象。

        例如上面的例子，还可以这样写：

public class CreateThreadTest {
	public static void main(String[] args) {
		T r=new T();
		Thread t=new Thread(r);    //创建线程对象
		t.start();    //T类的线程开始
		for(int i=0;i<100;i++)
		{
			System.out.println("主线程正在执行~~~~"+i);
		}
	}
}
class T implements Runnable 
{
	public void run(){
		for(int i=0;i<100;i++)
		{
			System.out.println("我创建的线程正在执行~~~~"+i);
		}
	}
}

       两种方法的实质就是，都需要重写run方法，最终都是由Thread类的start方法启动线程。

       温馨提示：因为Java中不支持多继承，所以实现线程时，一旦继承了Thread类，就无法再继承其他类了。但Java支持实现多个接口，所以推荐采用第二中方法，比较灵活。

       多线程

       多线程主要是为了同步完成多项任务，即同时执行多个线程。多线程把一个进程划分为多个任务，它们彼此独立地工作

       我们都知道，现在大部分操作系统比如Windows、Mac OS X、Unix、Linux等，都是支持多线程的，但我们平时所说的多线程，并不意味着CPU在同时会处理多个线程，每个CPU在同一个时间点只会处理一个线程，只不过速度太快了，处理的时间极短，以至于我们可以认为它是在同一个时间段可以处理多个线程。所以只有当你的机器是“双核”甚至“多核”时，才能实现真正意义上的多线程。                                                                                            

       下面看一个多线程的例子：

        两个线程t1和t2的执行        

public class ThreadTest {
	public static void main(String[] args) {
		Thread t1=new Thread(new T1());
		Thread t2=new Thread(new T2());
		t1.start();t2.start();
	}	
}
class T1 implements Runnable{
	public void run(){
		for(int i=0;i<10;i++){
			System.out.println("线程1正在执行中------"+i);
			if(i==9){
				System.out.println("线程1执行已结束------"+i);
				break;
			}
		}
	}
}
class T2 implements Runnable{
	public void run(){
		for(int i=0;i<10;i++){
			System.out.println("线程2正在执行中------"+i);
			if(i==9){
				System.out.println("线程2执行已结束------"+i);
				break;
			}
		}
	}
}

         执行结果：

       是不是跟您预测的不一样呢?如果不加线程的话，本来的结果应该前十行都是线程1在执行，线程1执行完后线程2才开始执行，线程调度算法使得每个线程执行一会进入等待状态，再去执行另一个线程。

       线程中常用的方法

       如果亲手尝试过上面这个例子中，会发现这两个线程t1和t2谁先执行，谁后执行，谁执行多长时间等等这些都是不确定、不可控的。下面就说一下线程中常用到的几个方法。

       ★ void yield()方法

       在一个线程中，如果执行到yield()方法，那么这个线程就会让出CPU资源，暂停当前正在执行的线程对象，转而让CPU去执行其他具有相同优先级的线程。充分体现了线程乐于谦让的精神！

       例：i的值从0到99，每次输出线程实例的名字，当i是10的倍数时，执行yield方法。 

 public class TestYield {
	public static void main(String[] args) {
		MyThread thread1=new MyThread("thread1");
		MyThread thread2=new MyThread("thread2");
		thread1.start();thread2.start();
	}
}
class MyThread extends Thread{
	MyThread(String name){
		super(name);
	}
	public void run(){
		for(int i=0;i<100;i++){
			System.out.println(getName()+":"+i);
			if(i%10==0){
				yield();
			}
		}
	}
}

      注意： yield()方法会将当前运行的线程切换到可运行状态，但可能没有效果，因为实际中执行yield方法的线程还有可能被调度程序再次选中。

      ★ void sleep(long millis)方法和void sleep(long millis,int nanos)

       让线程休眠（暂停执行）指定的时间长度，参数millis的单位是毫秒，参数nanos的单位是纳秒。线程执行了sleep方法后就会进入阻塞状态，指定的时间段过后，线程进入可执行状态，等待被操作系统调度。

       例：      

import java.util.*;
public class TestSleep {
	public static void main(String[] args)
	{
		MyThread thread=new MyThread();
		thread.start();
	}
}
class MyThread extends Thread
{
	public void run()
	{
		while(true)
		{
			System.out.println("==="+new Date()+"===");
			try{
				sleep(1000);
			}catch(InterruptedException e){
				return;
			}
		}
	}
}

         ★void join()方法

         上面说线程执行了yield方法时，会自动让出CPU资源，使状态由运行状态转换为可运行状态。join()方法可以说是恰恰相仿，当一个线程执行了join方法时，那么它就会一直执行下去直到这个线程结束。

        还是举例来说明：

public class TestJoin {  
    public static void main(String[] args) throws InterruptedException {  
        Thread t1 = new Thread(new ThreadA());  
        Thread t2 = new Thread(new ThreadB());  
        t1.start();  
        t1.join(); // t1线程开始执行后，它将继续执行下去，直到t1线程结束，否则绝不让出CPU  
        t2.start();  
        t2.join(); // t2线程开始执行后，它将继续执行下去，直到t1线程结束，否则绝不让出CPU  
    }  
}
class ThreadA implements Runnable {   
    public void run() {  
        for (int i=0;i<10;i++) {  
            System.out.println("A线程正在运行~~~~" + i);  
        }   
    }  
}   
class ThreadB implements Runnable {   
	public void run() {  
        for (int i=0;i<10;i++) {  
            System.out.println("B线程正在运行~~~~" + i);  
        }   
    }   
} 

        为什么要用多线程

        最后一个问题，为什么要用多线程?

        在论坛里看到一个大牛的比喻：单线程就是牛逼老板从头到尾一个人做完，另开一个线程就是老板掰出一件事情叫一个小弟去做，这个小弟的进入会加快整个事情的进展，但有时可能会做起事来碍手碍脚。

       当然，想要更深地理解多线程的精髓所在，光靠学这些理论还是不够的，更重要的还是在实践和项目中去挖掘和思考。

J2SE快速进阶——Java多线程机制

标签：

原文地址：http://blog.csdn.net/huyuyang6688/article/details/44056119