多线程01——线程的启动有规律但执行没有规律

朴灿烈づ我的快乐病毒、 2022-02-03 11:34 155阅读 0赞

多线程是指在同一个进程中有多个顺序流同时执行。一个应用程序由一个或多个进程组成。

应用程序是Application，比如迅雷这款软件；进程是Process，迅雷至少包括了界面进程和下载进程；线程是Thread，迅雷的下载进程里面有多个线程一起工作，才能完成下载功能。

在并发环境中，默认条件下多线程里的方法的执行顺序是随机无序的，并不是按照比如线程对象的创建顺序、start()方法的先后执行顺序而先后顺序执行。比如Thread-0和Thread-1执行一个相同的方法，Thread-0这个线程虽然是先创建的，但其内部的方法不一定最先完成。

注意，这里的随机无序指的是线程里的方法。线程的创建是有序的，谁先执行start()方法谁就先被创建。即启动顺序不等于执行顺序。  
因为执行一个线程时，线程并不会立即执行，而是等待CPU的资源调度，CPU能调度哪个线程，是与底层物理硬件相关的，外界无法控制。  
程序员可以控制的是程序是否抢占CPU资源。

Java里面多线程要执行的代码要放在run()方法内部，run()方法的方法体也被称为线程体。

更为通俗的理解是将run()方法作为主线程外其它线程的入口方法，即run()方法之于其它线程的地位相当于主线程的main()方法。

简单的开启多线程方式有两种：继承Thread类、实现Runnable接口。

/**
     * 实现Runnable接口
     * @author Zhang
     *
     */
    public class MyRunThread implements Runnable{
    	//run()方法相当于主线程中的main方法，run()是该线程入口
    	@Override
    	public void run() {
    		System.out.println("实现接口线程名称>>"+Thread.currentThread().getName());
    		otherThreadMethod();
    	}
    	
    	public static void otherThreadMethod() {
    		for(int i=1;i<=5;i++) {
    			System.out.println("实现Runnable>>"+Thread.currentThread().getName()+"：数值>>"+i);
    		}
    	}
    	
    }

/**
     * 继承Thread类
     * @author Zhang
     *
     */
    public class MyThread extends Thread{
    	@Override
    	public void run() {
    		System.out.println("继承Thread线程名称>>"+Thread.currentThread().getName());
    		otherMethod();
    	}
    	public void otherMethod() {
    		for(int i=1;i<=5;i++) {		
    			System.out.println("继承Thread>>"+Thread.currentThread().getName()+"：数值>>"+i);
    		}
    	}
    }

对以上多线程类进行启动，启动的标准是看是否调用了start()方法，因为主线程是必须启动且先启动，其它线程的启动看start()方法的先后顺序，所以下面的线程启动顺序一定是主线程、继承Thread的线程、实现接口的两个线程，但是各个线程之间方法的执行是无序的。

public class Test {
    	//主方法本身所在的是主线程
    	public static void main(String[] args) {
    		System.out.println("主线程名称>>"+Thread.currentThread().getName());
    		//创建Runnable实现类对象
    		MyRunThread runThread=new MyRunThread();
    		//创建继承Thread类的多线程对象
    		Thread thread=new MyThread();
    		//Runnable实现类传入Thread
    		Thread runTthread1=new Thread(runThread);
    		Thread runThread2=new Thread(runThread);			
    		//启动一个线程
    		thread.start();
    		//启动一个线程
    		runTthread1.start();
    		//启动一个线程
    		runThread2.start();
    		
    		//执行主线程中方法
    		mainMethod();
    		
    	}
    	
    	public static void mainMethod() {
    		for(int i=1;i<5;i++) {
    			System.out.println("主线程>>"+Thread.currentThread().getName()+"：数值>>"+i);
    		}
    	} 
    	
    }

结果：

主线程名称>>main
    主线程>>main：数值>>1
    主线程>>main：数值>>2
    实现接口线程名称>>Thread-2
    实现Runnable>>Thread-2：数值>>1
    实现Runnable>>Thread-2：数值>>2
    实现Runnable>>Thread-2：数值>>3
    实现Runnable>>Thread-2：数值>>4
    实现Runnable>>Thread-2：数值>>5
    主线程>>main：数值>>3
    实现接口线程名称>>Thread-1
    实现Runnable>>Thread-1：数值>>1
    继承Thread线程名称>>Thread-0
    实现Runnable>>Thread-1：数值>>2
    主线程>>main：数值>>4
    实现Runnable>>Thread-1：数值>>3
    继承Thread>>Thread-0：数值>>1
    实现Runnable>>Thread-1：数值>>4
    继承Thread>>Thread-0：数值>>2
    实现Runnable>>Thread-1：数值>>5
    继承Thread>>Thread-0：数值>>3
    继承Thread>>Thread-0：数值>>4
    继承Thread>>Thread-0：数值>>5

具体而言，主线程内子线程start()后并不一定立即执行子线程内的run()方法。

public class MyRunThread implements Runnable{
    	//run()方法相当于主线程中的main方法，run()是该线程入口
    	@Override
    	public void run() {
    		//获取当前线程名称
    		System.out.println("线程类内，子线程名称："+Thread.currentThread().getName());
    		otherThreadMethod();
    	}
    	
    	public static void otherThreadMethod() {
    		for(int i=1;i<=5;i++) {
    			System.out.println(Thread.currentThread().getName()+"：数值>>"+i);
    		}
    	}
    	
    }
    
    //测试类
    
    public class Test {
    	
    	public static void main(String[] args) {
    		//获取当前线程名称
    		System.out.println("主线程名称>>"+Thread.currentThread().getName());
    		
    		//创建一个子线程
    		Runnable runThread=new MyRunThread();
    		Thread thread1=new Thread(runThread);
    
    		//启动1个子线程
    		thread1.start();
    
    		//获取子线程的默认名称
    		System.out.println("子线程名称>>"+thread1.getName());
    		//设置子线程名称
    		thread1.setName("子线程1");
    		//执行主线程中方法
    		mainMethod();
    	}
    	
    	public static void mainMethod() {
    		for(int i=1;i<5;i++) {
    			System.out.println(Thread.currentThread().getName()+"：数值>>"+i);
    		}
    	} 
    	
    }

结果如下，可以发现run()方法执行的获取子线程名称是在主方法setName后的结果，所以证实了start()之后并不一定会立即执行run()方法，因为主线程的资源让出，子线程才有可能执行。

主线程名称>>main
    子线程名称>>Thread-0
    main：数值>>1
    main：数值>>2
    线程类内，子线程名称：子线程1
    子线程1：数值>>1
    子线程1：数值>>2
    子线程1：数值>>3
    子线程1：数值>>4
    子线程1：数值>>5
    main：数值>>3
    main：数值>>4