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

时间：2021-10-12 17:29:35

        

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

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

   

        线程的实现

        当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;
}
}
}
}
         看下面的结果之前，先充分发挥你的大脑想一想到底结果应该是什么样子的~~

         执行结果：

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

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

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

      注意： 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风扇也会“唰唰唰”~~~~）。

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

         ★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方法，那么它们一旦开始执行，就将执行到底，如右下图。

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

        为什么要用多线程

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

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


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


标签：

相关文章