Java之线程

朴灿烈づ我的快乐病毒、 2022-04-17 02:48 194阅读 0赞

# **线程的生命周期** #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzQxODYxNzUx_size_16_color_FFFFFF_t_70][]

*  **新建状态:**
    
    使用 **new** 关键字和 **Thread** 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 **start()** 这个线程。
 *  **就绪状态:**
    
    当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。
 *  **运行状态:**
    
    如果就绪状态的线程获取 CPU 资源，就可以执行 **run()**，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
 *  **阻塞状态:**
    
    如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：
    
     *  等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
     *  同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
     *  其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。
 *  **死亡状态:**
    
    一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

## 创建一个线程 ##

Java 提供了三种创建线程的方法：

*  通过继承 Thread 类本身；
 *  通过实现 Runnable 接口；
 *  通过 Callable 和 Future 创建线程。

1）.通过继承 Thread 类本身；

创建2个类

![20181112112220248.png][]

package Thread.ThreadDemo01;
    
    /**
     * 
     * @author zzy
     * 
     * 实现的步骤：
     *      1.创建一个类继承 Thread
     *      2.使用线程，创建子类对象 
     *      3.子类对象 调用start()方法  ，线程启动 ，CPU调用运行
     * 
     *
     */
    public class Rabbit extends Thread {
    	@Override
    	public void run() {
    		for(int i = 0 ;i<1000;i++) {
    			System.out.println("兔子正在跑........");
    			
    		}
    	}
    	
    }
    class Tortoise extends Thread{
    	@Override
    	public void run() {
    		for(int i = 0 ;i<1000;i++) {
    			System.out.println("乌龟正在跑........");
    			
    		}
    	}
    	
    }

package Thread.ThreadDemo01;
    
    public class MainT {
    
    	public static void main(String[] args) {
    		//注意千万不要调用run方法
    		Rabbit rabb = new Rabbit();
    		Tortoise tor = new Tortoise();
    		rabb.start();  
    		tor.start();	
    	}
    	
    
    }

继承Thread类的方式的缺点：那就是如果我们的类已经从一个类继承（就是继承了其它类），则无法继承Thread类。

2).通过实现 Runnable 接口；

学习之前   你先了解什么是代理模式（[https://mp.csdn.net/postedit/83990134][https_mp.csdn.net_postedit_83990134]）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzQxODYxNzUx_size_16_color_FFFFFF_t_70 1][]

package Thread.ThreadDemo02;
    
    
    /*
     * 使用Runnable
     * 
     * 1.类实现Runnable接口  并重写run()  -->真实的角色类
     * 2. 启动多线程 使用静态代理
     *       创建真实角色
     *       创建代理角色+真实角色的引用
     *       调用start方法   启动线程
         
     */
    
    public class Programener implements Runnable {
    
    	@Override
    	public void run() {
    		for(int i = 0 ;i<100;i++) {
    			System.out.println("吃饭....看书....");
    		}
    		
    	}
    
    }

package Thread.ThreadDemo02;
    
    public class APP{
    	
    	public static void main(String[] args) {
    		//1.创建真实角色
    		Programener pro = new Programener();
    		//2.  创建代理角色+真实角色的引用  Thread的有参构造方法
    		Thread proxy = new Thread(pro);  
    		//3.调用start方法   启动线程
    		proxy.start();
    		
    		for(int i = 0 ;i<100;i++) {
    			System.out.println("玩手机....");
    		}
    	}
    	
    }

通过实现 Runnable 接口，优点是：可以同时实现继承。避免了单继承，方便了共享资源

3).通过 Callable 和 Future 创建线程。

package Thread.ThreadDemo03;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    
    public class Call {
    	public static void main(String[] args) throws InterruptedException, ExecutionException {
    		//创建1个线程
    	       ExecutorService ser = Executors.newFixedThreadPool(2);
    	       Race tortoise1 = new Race("乌龟",1000);
    	       Race tortoise2= new Race("兔子",500);
    	     
    	       
    	       
    	       //获取值
    	       Future<Integer> result1 = ser.submit(tortoise1);
    	       Future<Integer> result2 = ser.submit(tortoise2);
    	       
    	       
    	       Thread.sleep(2000);
    	       tortoise1.setFlag(false);
    	       tortoise2.setFlag(false);
    	       
    	       int num1 = result1.get();
    	       int num2 = result2.get();
     
    	       System.out.println("乌龟"+num1+"步");
    	       System.out.println("兔子"+num2+"步");
    	       ser.shutdownNow();
    	}
    
    }
    class Race implements Callable<Integer> {
    	private String name; //名称
    	private int time;  //延时时间
    	private boolean  flag = true;  //停止线程
    	private int step = 0 ;//步
    	public Race() { 
    		
    	}
    	public Race(String name) {
    		this.name = name;
    	}
    	public Race(String name, int time) {
    		this.name = name;
    		this.time = time;
    	}
    	@Override
    	public Integer call() throws Exception {
    		// TODO Auto-generated method stub
    		while(flag) {
    			Thread.sleep(time);
    			step++;
    		}
    		return step;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getTime() {
    		return time;
    	}
    	public void setTime(int time) {
    		this.time = time;
    	}
    	public boolean isFlag() {
    		return flag;
    	}
    	public void setFlag(boolean flag) {
    		this.flag = flag;
    	}
    	public int getStep() {
    		return step;
    	}
    	public void setStep(int step) {
    		this.step = step;
    	}
    	
    	
    }

比较繁琐，但是可以返回值  和 对外声明异常

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzQxODYxNzUx_size_16_color_FFFFFF_t_70]: /images/20220417/09d05fe8f1644ec483d1c2b81e46b890.png
[20181112112220248.png]: /images/20220417/695715c2f4984f7c8c3f0beee03c5d45.png
[https_mp.csdn.net_postedit_83990134]: https://mp.csdn.net/postedit/83990134
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzQxODYxNzUx_size_16_color_FFFFFF_t_70 1]: /images/20220417/b727b1d6014d49528d9d70a06df37e78.png