Java线程深入解析-优快云博客

进程

软件在运行时一种状态。会占用CPU、内存等号资源。

线程

代码的执行路径，是进程的组成部分，一个进程可以有多个线程。每个线程都可以执行自己的内容或者多个线程共同执行一个任务

线程实例

public class TestThread {
	public static void main(String[] args) {
		//创建线程接口的对象  匿名内部类-实例化，接口，抽象类
		Runnable rb = new Runnable () {
			@Override
			public void run() {
				System.out.println("我是子线程" + Thread.currentThread().getName());
				
				}
			};
			
			//创建线程对象，并定义线程要做的事情
			
			Thread td = new Thread(rb);
			
			//主函数的线程启动
			
			td.run();
			
			System.out.println("主线程：" + Thread.currentThread().getName());
			
	}
}

在这里插入图片描述

线程说明

1.Java中的线程类：Thread
2.Java中的线程都需要接口，线程接口：Runnable
接口内部只有一个方法：run
public void run()；
3.每次在写子线程的时候，都需要在run方法内部实现自己要干的事情
4.启动线程是用的start方法

线程的创建方式

1.实现Runnable接口
2.自定义类实现Thread类的子类，重写run方法
3.实现Callable接口

1.实现Runnable接口实现线程
要求：
1.采用匿名内部类直接完成接口的实例化，并重写run方法
2.自定义类实现接口，重写run方法

public class MyRunnable implements Runnable{

	@Override
	public void run() {
		//子线程实现数羊
		for (int i = 0; i < 101; i++) {
			System.out.println("子线程-数羊" + i + "只羊");
		}
		
	}
	public static void main(String[] args) {
		//1.创建接口的实例化对象
		MyRunnable mr = new MyRunnable();
		
		//2.创建线程对象
		
		Thread td = new Thread(mr);
		
		//主函数启动
		
		td.start();
	}
}

继承Thread类实现线程
创建类继承Thread，并重写run方法

public class HelloThread extends Thread{
	@Override
	public void run() {
		
		System.out.println("继承线程，实现子线程");
	}
	
	public static void main(String[] args) {       
		//1.实例化自定义线程类对象      
		HelloThread ht=new HelloThread();        
		
		//2.启动子线程      
		ht.start();  

	}
}

在这里插入图片描述
使用Callable实现线程
jdk新版本推出线程创建方式，线程可以带返回值。
1.实现Callable接口，并指定线程的返回值类型
2.创建FutureTask对象
3.创新线程对象，并传递任务对象
4.启动线程
5.获取线程的返回

public class MyCallable implements Callable<Integer>{   
 @Override    
 public Integer call() throws Exception {        
 System.err.println("子线程，带返回值的");        
 return new Random().nextInt(10);    } 
 }
    public static void main(String[] args) throws InterruptedException, ExecutionException {       
     //1.创建 Callable接口的实现类对象       
     MyCallable mc=new MyCallable();       
      //2.创建任务对象       
       FutureTask<Integer> ft=new FutureTask<Integer>(mc);       
        //3.创新线程对象        
        Thread td=new Thread(ft);        
        //4.启动线程        
        td.start();       
         //5.获取线程的返回值 只有在线程执行结束之后才会返回        
         System.err.println("返回值："+ft.get());   
          }

## 线程的状态
线程有五大状态，分别是新建，就绪，运行，阻塞，销毁
新建：
当我们实例化线程对象的时候，线程就是新建状态
就绪：
当我们调用线程的start方法之后，线程就会进入就绪状态
处于该状态的线程，随时都可以获取CPU调度
当线程因为资源竞争，或主动方法调用，让线程进入到阻塞。
常见：sleep、wait、join等等
销毁：
当线程的run方法执行结束之后，就会进入到销毁状态
敲黑板：程序的结束就是指的内部多的所有线程全部进入到了销毁状态
## 线程的分类
线程分为：用户线程和守护线程

```java
  public static void main(String[] args) {       
   // 代码演示线程的类型 用户线程和守护线程       
    //默认的就是用户线程        
    Thread th=new Thread(new Runnable() {                       
     @Override          
       public void run() {                            
       System.err.println("子线程");          
         }       
          });      
        th.start()

 //创建守护线程        
 Thread th2=new Thread(new Runnable() {                   
  @Override                  
    public void run() {                                         
      System.err.println("子线程--守护线程");                    
      }               
       });        
       //设置当前的线程对象是否为守护线程，默认为false        
       th2.setDaemon(true);        
       //启动线程       
        th2.start();    
        }