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

约定不等于承诺〃 2022-08-07 03:48 158阅读 0赞

学习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方法中，从①执行到⑥是一条线，并没有分支，这就是一个线程。

![Center][]

###         **线程的实现** ###

当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);
    		}
    	}
    }

现在，这一个小程序一共有两个线程正在执行，一个是主线程，还有一个是T类创建的线程。

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;
    			}
    		}
    	}
    }

看下面的结果之前，先充分发挥你的大脑想一想到底结果应该是什么样子的~~

执行结果：

![Center 1][]

是不是跟您预测的不一样呢?如果不加线程的话，本来的结果应该前十行都是线程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();
    			}
    		}
    	}
    }

从结果中的前几条输出可以发现，对thread1来说，每当i是10的倍数时，进程就会让出，thread2进程执行；thread2也是如此：

![Center 2][]   ![Center 3][]

注意： 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;
    			}
    		}
    	}
    }

看完代码您应该猜到结果了，每隔一秒都会输出当前时间，相当于一个定时器。这个程序一共有两个线程，主线程（即main方法）中出了执行thread线程就没有其他任务需要执行，所以这里可以看做只执行thread这一个线程，如果把例子中的sleep方法去掉，那么就会“唰唰唰”地不断输出当前时间（你的CPU风扇也会“唰唰唰”~~~~）。

![Center 4][]

★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);  
            }   
        }   
    }

先来设想一下，加入t1和t2两个线程启动后不执行join方法，那么CPU给它们分配的执行时间和顺序就不一定相同，如左下图；如果t1和t2执行了join方法，那么它们一旦开始执行，就将执行到底，如右下图。

![Center 5][]         ![Center 6][]

**为什么要用多线程**

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

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

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

[Center]: /images/20220805/9eab09ca1395421eb4f0d73ca4057918.png
[Center 1]: /images/20220805/a69c5a07086c47e3b7f475a9d30ebffe.png
[Center 2]: https://img-blog.csdn.net/20150307163145833?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvaHV5dXlhbmc2Njg4/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 3]: /images/20220805/1a9dbc63279c41c6bc232ce4d895d50d.png
[Center 4]: /images/20220805/55f78f5e2a2946e896f36c5258ed150b.png
[Center 5]: https://img-blog.csdn.net/20150308171558963?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvaHV5dXlhbmc2Njg4/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 6]: /images/20220805/ebad1d2f208b4b35a4dd32033dfafd47.png