java多线程学习笔记（一）基本概念

浅浅的花香味﹌ 2022-11-17 05:58 131阅读 0赞

## 一、进程，线程，多线程 ##

*  1.程序：指指令和数据的有序集合，其本身没有任何意义，是一个静态的概念
 *  2.进程：指执行程序的一次执行过程，是一个动态的概念。是系统资源分配的单位（注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。即在一个cpu的情况下，在同一时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉）
 *  3.线程：通常一个进程中可以包含若干个线程，一个进程中至少有一个线程。线程是cpu调度和执行的单位
 *  4.并行：指在同一时刻，有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看，二者都是一起执行的。
 *  5.并发：同一时间段内，多个任务都在执行。他们之间共享cpu的执行时间片段。多个任务之间并不是同时执行的。

## **二、线程的创建** ##

> （1）继承Thread类 （2）实现Runnable接口 （3）实现Callable接口

**（1）继承Thread类**

*  自定义线程类继承Thread类；
 *  重写run()方法，编写线程执行体；
 *  创建线程对象，调用start()方法启动线程。

public class Thread_Test extends Thread {
        
     
    	int count = 10;
    
      	public void run() {
        
    		method();
    	}
     
    	public void method() {
        
    		for (int i = 0; i < 5; i++) {
        
    			count--;
    			System.out.println(Thread.currentThread().getName() + "    " + count);
    		}
    	}
     
    	public static void main(String[] args) {
        
    	
    		Thread_Test thread = new Thread_Test();
    		thread.setName("A");
    		thread.start();
     
    		Thread_Test thread2 = new Thread_Test();
    		thread2.setName("B");
    		thread2.start();
    		}
    }

**注意点：** 由于java只支持单继承，所以不建议使用该方式

**（2）实现Runnable接口**

*  定义类实现Runnable接口；
 *  实现run()方法，编写线程执行体；
 *  创建线程对象，调用start()方法启动线程。

public class TestThread04 implements Runnable{
        
    
        //票数
        private int ticketNums = 10;
    
        @Override
        public void run() {
        
            while (true){
        
                if (ticketNums <=0 ){
        
                    break;
                }
                //模拟延时
                try {
        
                    Thread.sleep(200);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"票");
            }
        }
    
        public static void main(String[] args) {
        
            TestThread04 ticket = new TestThread04();
    
            new Thread(ticket,"小明").start();
            new Thread(ticket,"老师").start();
            new Thread(ticket,"黄牛").start();
        }
    }

**（3）实现Callable接口（一般不使用）**

*  实现Callable接口，需要返回值类型
 *  重写call方法，需要抛出异常
 *  创建目标对象
 *  创建执行服务：ExecutorService ser=Executors.newFixedThreadPool(1);
 *  提交执行：Future result1 = ser.submit(t1);
 *  获取结果:boolean r1 = result1.get()
 *  关闭服务：ser.shutdownNow();

public class TestCallable implements Callable<Boolean> {
        
    
        private String url;//网络图片地址
        private String name;//保存文件名
    
        public TestCallable(String url, String name) {
        
            this.url = url;
            this.name = name;
        }
    
        //下载图片的线程执行体
        @Override
        public Boolean call() {
        
            WebDownLoader webDownLoader = new  WebDownLoader();
            webDownLoader.downLoader(url,name);
            System.out.println("下载了文件名为"+name);
            return true;
        }
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            TestCallable t1 = new TestCallable("https://i.guancha.cn/bbs/2020/07/10/20200710142345269.jpg?imageView2/2/w/500/format/jpg","1.jpg");
            TestCallable t2 = new TestCallable("https://i.guancha.cn/bbs/2020/07/10/20200710142345269.jpg?imageView2/2/w/500/format/jpg","2.jpg");
            TestCallable t3 = new TestCallable("https://i.guancha.cn/bbs/2020/07/10/20200710142345269.jpg?imageView2/2/w/500/format/jpg","3.jpg");
    
            //创建执行服务
            ExecutorService ser= Executors.newFixedThreadPool(3);
            //提交执行
            Future<Boolean> r1 = ser.submit(t1);
            Future<Boolean> r2 = ser.submit(t2);
            Future<Boolean> r3 = ser.submit(t3);
            //获取结果
            boolean rs1 = r1.get();
            boolean rs2 = r2.get();
            boolean rs3 = r3.get();
    
            System.out.println(rs1);
            System.out.println(rs2);
            System.out.println(rs3);
    
            //关闭服务
            ser.shutdownNow();
        }
        //下载器
        class WebDownLoader{
        
            //下载方法
            public void downLoader(String url,String name){
        
                try {
        
                    FileUtils.copyURLToFile(new URL(url),new File(name));
                } catch (IOException e) {
        
                    e.printStackTrace();
                    System.out.println("io异常，downloader方法出现问题");
                }
            }
        }
    }

## **三、线程的五大状态** ##

> **1. new（新建状态）：** 新创建了一个线程对象。  
> **2. Runnable（就绪状态）：** 线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权、  
> **3. Running（运行状态）：** 可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。  
> **4. Blocked（阻塞状态）：** 阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种：  
> **(一). 等待阻塞：** 运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。  
> **(二). 同步阻塞：** 运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。  
> **(三). 其他阻塞：** 运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。  
> **5. Dead（死亡状态）：** 线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk4MTMxNQ_size_16_color_FFFFFF_t_70]

**3.1、线程的停止**  
\*\*（1）自然停止：\*\*当线程体自然执行完毕后，线程便会自然终止；  
\*\*（2）使用标志位：\*\*线程内部当flag为true才可执行，外部可通过置flase来终止线程；

//线程部分
    class Study implements Runnable{
        
        private boolean flag = true;
        @Override
        public void run() {
        
            while (flag){
        
                System.out.println("study thread");
            }
        }
        public void stop(){
        
            this.flag = false;
        }
    }

//外部调用部分
    Study study = new Study();
    new Thread(study).start();
    for (int i=0;i<100;i++){
        
        if (i==50)
            study.stop();
    }

**（3）stop和destory方法（不建议使用）**

**3.2线程的阻塞**  
**（1）join方法：** 可以理解为霸道的插队，当一个线程在执行时，调用了join的方法后，其他的线程必须等到执行join的线程运行完毕后，才可以继续启动。

*  **应用：** 子线程处理一个数据，主线程要取得这个数据中的值，就要用到 join() 方法。

**（2）sleep方法：** 让当前正在执行的线程进行休眠一定秒数。

*  **注意：** 每一个对象都有一把锁。当该线程休眠的时候，不会释放锁。

**3.3、线程的礼让**

*  **yield（）方法：** yield方法可以实现暂停当前线程，执行其他的线程。它是一个static方法，暂停的具体线程取决于它执行的地方。
 *  **目的：** 让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
 *  **结论：** yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

**3.4、线程的优先级**  
我们可以为线程通过setPriority方法设置优先级，优先级的范围为1-10。下面是几个优先级的常量：

> MIN\_PRIORITY：最小优先级，值为1  
> NORM\_PRIORITY：正常优先级，线程的默认优先级，值为5  
> MAX\_PRIORITY：最大优先级，值为10

注意：优先级并不能代表先后顺序，只能导致执行的概率不同。优先级大的线程执行的概率会更大。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk4MTMxNQ_size_16_color_FFFFFF_t_70]: /images/20221022/f8e7fb6b8a014d8aba2bb93529a6a202.png