[1.JavaSE] 6 线程

最新推荐文章于 2024-06-12 23:05:18 发布

Fu笙

最新推荐文章于 2024-06-12 23:05:18 发布

阅读量38

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/I_O_Lot/article/details/131509227

版权

6.多线程

6.1 多线程概念

进程是什么(process)

对一个程序的运行状态, 以及在运行中所占用的资源(内存, CPU)的描述;

一个进程可以理解为一个程序; 但是反之, 一个程序就是一个进程, 这句话是错的。

进程的特点:

独立性: 不同的进程之间是相互独立的, 相互之间资源不共享；
动态性: 进程在程序中不是静止不动的, 而是一直是活动状态；
并发性: 多个进程可以在一个处理器上同时运行, 互不影响；

线程是什么(thread)

是进程的一个组成部分, 一个进程中可以包含多个线程, 每一个线程都可以去处理一项任务；

进程在开辟的时候, 会自动的创建一个线程, 这个线程叫做主线程；

一个进程包含多个线程, 且至少是一个, 如果一个进程中没有线程了, 这个进程会被终止；

多线程的执行是抢占式的, 多个线程在同一个进程中并发执行任务, 其实就是CPU快速的在不同的线程之间进行切换,

进程与线程的关系和区别

一个程序运行后, 至少有一个进程
一个进程包含多个线程, 至少一个线程
进程之间是资源不共享的, 但是线程之间是资源共享的
系统创建进程的时候, 需要为进程重新分配系统资源, 而创建线程则容易很多, 因此使用多线程在进行并发任务的时候, 效率比多进程高

区别并行和并发

并行：指在同一时刻，有多条指令在多个处理器上同时执行；

并发：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行；

6.2 创建线程的方式

继承Thread类

Thread是所有线程类的父类, 实现了对线程的抽取和封装；

使用继承Thread类实现多线程的步骤:

继承Thread类, 写一个Thread的子类
在子类中, 重写父类中的run方法, run方法就代表了这个线程需要处理的任务(希望这个线程处理什么任务, 就把这个任务写到run方法中), 因此, run方法也被称为线程执行体
实例化这个子类对象, 即是开辟了一个线程
调用start方法, 来执行这个线程需要处理的任务(启动线程)

      public class Demo01 {
          public static void main(String[] args) {
              //创建自定义线程对象
              MyThread mt = new MyThread("新的线程！");
              //开启新线程
              mt.start();
              //在主方法中执行for循环
              for (int i = 0; i < 10; i++) {
                  System.out.println("main线程！"+i);
              }
          }
      }
      //自定义线程类
      public class MyThread extends Thread {
          //定义指定线程名称的构造方法
          public MyThread(String name) {
              //调用父类的String参数的构造方法，指定线程的名称
              super(name);
          }
          /**
           * 重写run方法，完成该线程执行的逻辑
           */
          @Override
          public void run() {
              for (int i = 0; i < 10; i++) {
                  System.out.println(getName()+"：正在执行！"+i);
              }
          }
      }

实现Runnable接口

实现Runnable接口, 并创建线程的步骤:

设计一个类, 实现Runnable接口, 并重写接口中的run方法, 在run方法中, 写上这个线程要处理的任务
创建Runnable实现类的对象, 并把这个对象作为Thread的target进行Thread对象的实例化, 这个Thread对象才是真正的线程对象
调用start方法, 来启动线程

      public class Demo02 {
      	public static void main(String[] args) {
      		//创建线程执行目标类对象
      		Runnable runn = new MyRunnable();
      		//将Runnable接口的子类对象作为参数传递给Thread类的构造函数
      		Thread thread = new Thread(runn);
      		Thread thread2 = new Thread(runn);
      		//开启线程
      		thread.start();
      		thread2.start();
      		for (int i = 0; i < 10; i++) {
      			System.out.println("main线程：正在执行！"+i);
      		}
      	}
      }
      //自定义线程执行任务类
      public class MyRunnable implements Runnable{
      
      	//定义线程要执行的run方法逻辑
      	@Override
      	public void run() {
      		
      		for (int i = 0; i < 10; i++) {
      			System.out.println("我的线程：正在执行！"+i);
      		}
      	}
      }

Callable

     class CallableThreadDemo implements Callable<Integer> {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            CallableThreadTest ctt = new CallableThreadTest();
            FutureTask<Integer> ft = new FutureTask<>(ctt);
            new Thread(ft, "有返回值的线程").start();
            System.out.println("子线程的返回值" + ft.get());
        }
    
        @Override
        public Integer call() {
            int i;
            for (i = 0; i < 10; i += 2) {
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
            return i;
        }
    }

三种方式的不同点

实现Runnable接口的方式:

线程对应的任务类, 只是实现了Runnable接口, 不会对原有的继承关系产生影响
多个线程可以使用同一个Runnable接口实现类对象来实例化, 非常适合多个线程访问相同的资源情况
弊端:
1. 编程稍微复杂, 不直观
  1. 如果需要获取到当前线程, 只能使用 Thread.currentThread() 来获取

继承Thread的方式:

编程简单, 直观,
如果需要访问当前线程, 直接用this即可, 也可以用 Thread.currentThread()
弊端:因为线程类继承自Thread类, 因此这个类不能再继承自其他类

实际上, 大多数需要用到多线程的情况, 都是使用的Runnable接口的方式来实现的 [推荐使用匿名内部类]

strart() 和 run() 的区别

start方法会开辟一个线程, 然后在这个新的线程中执行run中的逻辑

但是如果直接调用run(), 则表示需要在当前的线程中执行逻辑。

Runnable与Callable

相同点：都是接口，都可以编写多线程程序，都采用Thread.start()启动线程

不同点：Runnable没有返回值；Callable可以返回执行结果，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果

Callable接口的call()方法允许抛出异常；Runnable的run()方法异常只能在内部消化，不能往上继续抛

**注：**Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

6.3 线程常用的方法

线程的名字

    Thread thread = new Thread();
    // 设置线程的名字
    // 需要放到线程启动之前
    thread.setName(name);
    // 获取线程名字
    thread.getName();

线程休眠 sleep

让一个指定的线程, 释放CPU时间片, 进入阻塞状态

休眠时间结束后, 线程进入就绪状态, 开始争抢时间片

Thread.sleep(500): 时间单位是毫秒

会有一个InterruptedException异常

设置线程优先级 priority

可以通过设置线程的优先级, 来修改某一个线程抢到时间片的概率, 优先级越高的线程, 抢到CPU时间片的概率越高, 但是这不意味者, 优先级高的线程一定能抢到时间片

默认情况下, 每一个线程的优先级, 都与创建他的线程优先级相同

优先级的范围 [0,10], 新建的线程, 优先级默认是5.

设置线程的优先级, 需要在线程启动(start)之前

    thread.setPriority(2);

合并线程 join

在一个线程执行的过程中, 如果遇到了其他线程需要合并进来, 此时这个线程会释放CPU时间片, 去执行合并进来的线程. 合并进来的线程执行结束后, 再执行原来的逻辑.

特点:

线程合并, 当前线程一定会释放CPU时间片, 优先执行合并进来的线程
哪个线程需要合并到当前线程中, 就在当前线程中, 添加要合并的线程
合并之前, 线程一定要处于start

后台线程

一个隐藏起来的, 一直默默地在后面执行的线程, 直到程序结束

又叫做守护线程, 或者精灵线程,

JVM中的垃圾回收机制就是一个很典型的守护线程

如果所有的前台线程都死了, 后台线程会自动死亡

线程让步 yield

可以让当前的线程暂停, 但是不会进入阻塞, 只是从运行状态切换到了就绪状态, 完全可能出现的情况: 某一个线程yield暂停, 线程调度器又将其调度出来继续执行

实际上, 当某个线程使用yield让步后, 只有优先级与当前线程相同, 或者大于当前线程优先级的线程, 才有执行的机会

线程的生命周期

对于一个线程, 在被创建后, 不是立即就进入到了运行状态, 也不是一直处于运行状态, 在线程的声明周期中, 一个线程会在多种状态之间进行切换

new :创建状态, 线程被实例化, 但是还没有开始执行(start)

runnable: 就绪状态, 已经执行过start, 线程已经启动了, 只是没有抢到CPU时间片

running: 运行状态, 抢到了CPU时间片

blocked: 阻塞状态, 线程执行的过程中, 遇到一些特殊情况, 会进入阻塞状态. 阻塞中的线程, 是不能参数时间片的抢夺的 (不能被线程调度器调度)

dead: 死亡状态, 线程终止

正常死亡 : run方法中的代码执行结束

非正常死亡 : 强制使用stop方法停止这个线程

在这里插入图片描述

6.4 线程安全

临界资源问题：由于线程之间是资源共享的。如果有多个线程，同时对一个数据进行操作，此时这个数据会出现问题。

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

    public class ThreadDemo {
    	public static void main(String[] args) {
    		//创建票对象
    		Ticket ticket = new Ticket();
    		
    		//创建3个窗口
    		Thread t1  = new Thread(ticket, "窗口1");
    		Thread t2  = new Thread(ticket, "窗口2");
    		Thread t3  = new Thread(ticket, "窗口3");
    		
    		t1.start();
    		t2.start();
    		t3.start();
    	}
    }
    //模拟票
    class Ticket implements Runnable {
    	//共5票
    	int ticket = 5;
    
    	@Override
    	public void run() {
    		//模拟卖票
    		while(true){
    			if (ticket > 0) {
    				//模拟选坐的操作
    				try {
    					Thread.sleep(1);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    				System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
    			}
    		}
    	}

如果有一个线程在访问一个临界资源，在访问之前，先对这个资源“上锁”，此时如果有其他的线程也需要访问这个临界资源，需要先查这个资源有没有被上锁，如果没有被上锁，此时这个线程可以访问这个资源；如果上锁了，则此时这个线程进入阻塞状态，等待解锁。

6.5 线程同步

同步代码段

    // 同步代码段
    // 小括号：就是锁
    // 大括号：同步代码段，一般情况下，写需要对临界资源进行的操作
    synchronized () {
    	
    }
    // 关于同步锁：可以分成两种：对象锁、类锁
    // 同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。

    public class Ticket implements Runnable {
    	//共10张票
    	int ticket = 10;
    	//定义锁对象
    	Object lock = new Object();
    	@Override
    	public void run() {
    		//模拟卖票
    		while(true){
    			//同步代码块
    			synchronized (lock){
    				if (ticket > 0) {
    					//模拟电影选坐的操作
    					try {
    						Thread.sleep(10);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
    				}
    			}
    		}
    	}
    }

同步方法

    // 使用synchronized关键字修饰的方法就是同步方法
    // 将一个方法中所有的代码进行一个同步
    // 相当于将一个方法中所有的代码都放到一个synchronized代码段中
    // 同步方法的锁：
    // 1. 如果这个方法是一个非静态方法：锁是this
    // 2. 如果这个方法是一个静态方法：锁是类锁（当前类.class）
    private synchronized void sellTicket() {
    }

同步方法解决安全问题

    public class Ticket implements Runnable {
    	//共100票
    	int ticket = 100;
    	//定义锁对象
    	Object lock = new Object();
    	@Override
    	public void run() {
    		//模拟卖票
    		while(true){
    			//同步方法
    			method();
    		}
    	}
    
    //同步方法,锁对象this
    	public synchronized void method(){
    		if (ticket > 0) {
    			//模拟选坐的操作
    			try {
    				Thread.sleep(10);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
    		}
    	}
    }

lock与unlock

就是一个类RenntrantLock

    public class Ticket implements Runnable {
    	//共10票
    	int ticket = 10;
    	
    	//创建Lock锁对象
    	Lock ck = new ReentrantLock();
    	
    	@Override
    	public void run() {
    		//模拟卖票
    		while(true){
    			//synchronized (lock){
    			ck.lock();
    				if (ticket > 0) {
    					//模拟选坐的操作
    					try {
    						Thread.sleep(10);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
    				}
    			ck.unlock();
    			//}
    		}
    	}
    }

公平锁：谁等的时间最长的线程，优先获取锁

    public class Ticket implements Runnable {
    	//共10票
    	int ticket = 10;
    	
    	//创建Lock锁对象
    	Lock ck = new ReentrantLock(true);
    	
    	@Override
    	public void run() {
    		//模拟卖票
    		while(true){
    			//synchronized (lock){
    			ck.lock();
    				if (ticket > 0) {
    					//模拟选坐的操作
    					try {
    						Thread.sleep(10);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
    				}
    			ck.unlock();
    			//}
    		}
    	}
    }

等待唤醒机制

多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。

wait() 、notify() 、notifyAll()

wait(): 等待。使得当前的线程释放锁标记，进入等待队列。可以使当前的线程进入阻塞状态。

notify(): 唤醒，唤醒等待队列中的一个线程。

notifyAll(): 唤醒，唤醒等待队列中所有的线程。

wait和sleep的区别:

两个方法都可以使一个线程进入阻塞。
区别：wait方法会释放锁标记，sleep则不会释放锁标记。

    package kaikeba;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class ThreadDemo{
        public static void main(String[] args) {
            ResourceUnit r = new ResourceUnit();
            Producer p1 = new Producer(r, 1);
            Consumer c1 = new Consumer(r, 1);
            p1.start();
            c1.start();
        }
    }
    class ResourceUnit {
        private int contents;
        private boolean available = false;
        public synchronized int get() {
            while (available == false) {
                try {
                    wait();
                }
                catch (InterruptedException e) {
                }
            }
            available = false;
            notifyAll();
            return contents;
        }
        public synchronized void put(int value) {
            while (available == true) {
                try {
                    wait();
                }
                catch (InterruptedException e) {
                }
            }
            contents = value;
            available = true;
            notifyAll();
        }
    }
    
    class Consumer extends Thread {
        private ResourceUnit resourceUnit;
        private int number;
        public Consumer(ResourceUnit r, int number) {
            resourceUnit = r;
            this.number = number;
        }
        public void run() {
            int value = 0;
            for (int i = 0; i < 10; i++) {
                value = resourceUnit.get();
                System.out.println("消费者 #" + this.number+ " got: " + value);
            }
        }
    }
    
    class Producer extends Thread {
        private ResourceUnit resourceUnit;
        private int number;
    
        public Producer(ResourceUnit r, int number) {
            resourceUnit = r;
            this.number = number;
        }
    
        public void run() {
            for (int i = 0; i < 10; i++) {
                resourceUnit.put(i);
                System.out.println("生产者 #" + this.number + " put: " + i);
                try {
                    sleep((int)(Math.random() * 100));
                } catch (InterruptedException e) { }
            }
        }
    }

线程死锁(了解)

在解决临界资源问题的时候，我们引入了一个"锁"的概念。我们可以用锁对一个资源进行保护。实际，在多线程的环境下，有可能会出现一种情况：

假设有A和B两个线程，其中线程A持有锁标记a，线程B持有锁标记b，而此时，线程A等待锁标记b的释放，线程B等待锁标记a的释放。这种情况，叫做死锁。

6.6 线程池

线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

Java通过Executors提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

创建并使用线程池

通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。

Executors：线程池创建工厂类

public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象

ExecutorService：线程池类

Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行

Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

     public static void main(String[] args) {
            ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
            for (int i = 0; i < 10; i++) {
                final int index = i;
                fixedThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            System.out.println(index);
                            Thread.sleep(2000);
                            System.out.println(Thread.currentThread().getName());
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                });
            }
        }