java 线程《一》 java 实现多线程的三个方式

分手后的思念是犯贱 2021-09-19 14:36 358阅读 0赞

# 多线程的目的 #

多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。

# 并发 和并行 #

并发： 提高单处理器上的程序运行效率  
![在这里插入图片描述][20190525215559401.png]

并行： 多个cpu.

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70]

# 线程 和 进程 #

一条线程指的是进程中一个单一顺序的控制流  
一个进程中可以并发多个线程，每条线程并行执行不同的任务。

进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70 2]

# java 实现多线程的三个方式 #

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

## 1. 继承Thread类 ##

*  要启动一个线程，是调用start方法
 *  启动以后，会自动执行run方法
 *  如果没有执行start方法，直接调用run方法，就是普通的方法调用，没有启动多余的线程

package com.javabase;
    
    //实现一个线程的方式 1， 继承Thread类
    public class ThreadDemo1 extends Thread{
    	//线程启动以后，会自动运行run方法
    	public void run(){
    		System.out.println("ThreadDemo1>>run");
    		System.out.println(Thread.currentThread().getName());
    	}
    	
    	
    
    	public static void main(String[] args) {
    		System.out.println(Thread.currentThread().getName());
    		// TODO Auto-generated method stub
    		ThreadDemo1 t1=new ThreadDemo1();
    		//通过执行 start方法启动线程
    //		t1.start();
    		t1.run();
    	}
    
    }

main  
ThreadDemo1>>run  
main

执行start方法开一个新的线程

main  
ThreadDemo1>>run  
Thread-0

## 2 实现Runnable接口 ##

1.  相对于继承Thread类，推荐使用实现Runnable接口，理由是 java是单继承，但是可以同时实现多个接口。 所以如果通过实现接口的方式来实现多线程，就还可以继承其他的类

package com.javabase;
    
    //实现多线程的第二种方式： 实现runnable接口
    public class RunableDemo implements Runnable {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		RunableDemo r1=new RunableDemo();
    		Thread t1=new Thread(r1);
    		t1.start();
    	}
    
    	public void run() {
    		// TODO Auto-generated method stub
    		System.out.println("RunableDemo>>run");
    		System.out.println(Thread.currentThread().getName());
    	}
    
    }

RunableDemo>>run  
Thread-0

## 3 通过 Callable 和 Future 创建线程 ##

package com.javabase;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    public class CallableThreadTest implements Callable<Integer> {
        public static void main(String[] args)  
        {  
        	//创建一个callable类型对象
            CallableThreadTest ctt = new CallableThreadTest(); 
            //用FutureTask包装了callable对象
            FutureTask<Integer> ft = new FutureTask<>(ctt);  
            for(int i = 0;i < 100;i++)  
            {  
                System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
                if(i==20)  
                {  
                	//用Thread包装FutureTask，然后通过start方法
                	//启动一个新的线程
                    new Thread(ft,"有返回值的线程").start();  
                }  
            }  
            try  
            {  
                System.out.println("子线程的返回值："+ft.get());  
            } catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            } catch (ExecutionException e)  
            {  
                e.printStackTrace();  
            }  
      
        }
        //第三种多线程的实现方式：通过callable接口和FutureTask实现
        //第三种实现方式的好处：1， 线程的call方法可以有返回值，
        // 2， call方法可以往上抛异常
        @Override  
        public Integer call() throws Exception  
        {  
            int i = 0;  
            for(;i<100;i++)  
            {  
                System.out.println(Thread.currentThread().getName()+" "+i);  
            }  
            return i;  
        }  
    }

[20190525215559401.png]: /images/20210726/b94bc21d2f19450ea72931fbe8efdc4a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70]: /images/20210726/180e25a3b85448469cf34a80f97aa61f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70 1]: /images/20210726/87037647097a44cdb8acf39b5056dd7d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70 2]: /images/20210726/ee88cd4872f845b0adf1adf68524bc40.png