线程基础知识

柔光的暖阳◎ 2024-03-17 13:40 83阅读 0赞

#### 线程基础知识 ####

*  一.如何理解程序，进程，线程
 *  二.进程与线程的关系
 *  三.如何创建线程
 *  四.线程的优先级
 *  五.Thread类中的常用方法
 *  六.守护线程与用户线程
 *  七.线程的状态
 *  八.线程的生命周期
 *  九.多线程
 *   *  (1)什么是多线程
     *  (2)什么时候需要多线程
     *  (3)多线程的优点
     *  (4)多线程的缺点
 *  十.线程同步
 *   *  (1)并发和并行
     *  (2)线程同步
 *  十一.锁
 *   *  (1) synchronized关键字
     *  (2) LOCK锁
 *  十二.死锁
 *  十三.线程通信
 *   *  (1)什么是线程通信
     *  (2)线程通信中常用的三种方法
 *  十四.创建线程的第三种方式

## 一.如何理解程序，进程，线程 ##

程序:由编程语言写的一些代码集，主要指静态代码，一般存储在硬盘上.  
进程:运行中的程序，是操作系统资源分配的最小单位  
线程:进程中的最小执行单位，也是操作系统调度的最小单位  
一个进程内的所有线程共享该进程的内存资源

## 二.进程与线程的关系 ##

一个进程可以包含多个线程，而一个进程只能存在于一个进程当中，线程不能脱离进程而独立存在  
主线程可以产生多个子线程

## 三.如何创建线程 ##

方法一:通过继承Thread类,重写里面的run()方法，new自己的类对象，通过该对象调用start()方法来启动线程

//创建线程方法一
            MyThread myThread = new MyThread(); //MyThread类为自定义的继承了Thread类
            myThread.start();

方法二:通过自己的类实现Runnable接口,在里面重写run()方法，再通过new Thread()对象和new自己类的对象，用Thread对象将自己的类对象封装，再调用Thread对象中的start()方法来启动进程

RunTask runTask = new RunTask();//RunTask方法为自定义的类
           Thread thread = new Thread(runTask,"thread");
           Thread thread1 = new Thread(runTask,"thread1");
           thread.start();
           thread1.start();

## 四.线程的优先级 ##

事实上在早期的计算机中，只有一个cpu，当我们想进行多线程操作时，操作系统不得不利用一些线程调度算法来对进程进行管理和调用，常用的调度算法有很多，比如  
先来先服务，时间片轮转调度，优先级调度算法

我们这里的优先级就是优先级调度算法里的，一般java默认优先级为5，但也可以根据自己的需求在1-10之间设置，优先级越大意味着被操作系统调度的可能性越大，但并不意味着优先级大就会先被执行

现代cpu复杂，一般是在多种调度算法混用

## 五.Thread类中的常用方法 ##

run():里面写自己的业务逻辑  
start():用来启动线程,使线程进入就绪状态  
Thread(Runnable target,String name):构造方法，将自己的类对象变成单独的线程并命名  
Thread currentThread():返回当前正在执行的线程  
Thread currentThread().getName:获取当前正在执行该线程的线程名字  
Thread currentThread().getId:获取当前正在执行该线程的线程Id  
yied():让当前正在执行的线程做出线程让步，返回为就绪状态  
final void setPriority(int newPriority):设置线程的优先级  
final int getPriority():返回线程的优先级  
join():让当前进程先执行完在执行其他进程  
sleep():让程序阻塞指定时间再继续执行  
yield():主动让线程让步

## 六.守护线程与用户线程 ##

用户线程:除了守护线程其余的都是用户线程

守护线程:守护线程就是等到其他用户线程结束后，才能结束，否则守护线程将一直执行，主要是为用户线程提供服务

设置守护线程一定要在start()方法之前设置，调用setDaemon()方法

## 七.线程的状态 ##

新建:在new Thread之后所处的状态  
就绪:调用完start()方法后  
运行:获得了CPU的执行权  
阻塞:sleep(),join(),等待同步锁,wait()使该进程进入阻塞状态  
死亡:执行完run(),出现异常未处理,调用stop()方法

## 八.线程的生命周期 ##

![在这里插入图片描述][9cde893186ed403db5352f223527e31e.png]

## 九.多线程 ##

### (1)什么是多线程 ###

多线程是指在同一个程序中，可以创建多个线程互不干扰的同时执行不同的任务

### (2)什么时候需要多线程 ###

当我们需要用到多个线程同时执行各自的任务时，就需要用到多线程

### (3)多线程的优点 ###

提高程序的响应  
提高cpu利用率  
改善程序结构

### (4)多线程的缺点 ###

占用内存  
占用cpu资源,需要对多线程进行管理  
多线程同时对共享资源进行访问,如果不加以控制,会出现线程安全问题

## 十.线程同步 ##

### (1)并发和并行 ###

并发: 在一个时间段内,多个任务依次执行.  
并行: 是真正意义上的同时执行,一个时间节点上有多个任务同时执行.

### (2)线程同步 ###

上述讨论多线程缺点说到多线程在共享同一个资源时有可能导致安全问题,我们的解决方案就是引入线程同步机制，即各线程之间要先来后到

确保一个时间点只有一个线程访问共享资源。可以给共享资源加一把锁，哪个线程获取了这把锁，才有权利访问该共享资源

## 十一.锁 ##

### (1) synchronized关键字 ###

synchronized关键字可以解决线程安全问题，具体用法如下

(1)修饰代码块

> 修饰代码块时必须传入一个被多个线程所共有的对象,如果使用继承Thread的方法启动线程，那么就要new一个静态的object(也可以是其他对象)对象，如果是实现Runnable接口就只需用this即可

package Thread;
    
    public class RunTest {
        
        public static void main(String[] args) {
        
            RunThread wg = new RunThread("乌龟");
            RunThread tz = new RunThread("兔子");
            wg.start();
            tz.start();
        }
    }

public class RunThread extends Thread {
        
        String name;
        int count = 0;
        static boolean flag= true;
         static Object obj = new Object();//这就是待传入的两个线程所有的同一个对象
        public RunThread(String name){
        
            this.name = name;
        }
        @Override
        public void run() {
        
            for(int i=1;i<=20;i++){
        
                   count++;
                synchronized (obj) {
        //在这里传入
                       System.out.println(name+"已经走了"+count+"步");
                       if (count >= 20&&flag) {
        
                           flag = false;
                           System.out.println(name + "到达20步获胜");
                       }
                   }
           }
        }
    }

(2)修饰方法

> (1)在继承Thread类时，synchronized修饰静态方法默认是Class类的对象  
> (2)在继承Thread类时，synchronized饰普通方法默认是this,所以在这种创建线程时应当将方法设置为静态方法  
> (3)在实现Runnable接口时，因为创建的线程任务对象只有一个本身就是同一个对象，所以修饰方法时直接使用synchronized即可

package Thread;
    
    public class TicketThread extends Thread{
        
        static int count = 10;
        @Override
        public void run() {
        
            while(true){
        
                if(count<=0){
        
                    break;
                }
                    GetTicket();
    
            }
        }
        //synchronized修饰非静态方法，默认对象为this
        //synchronized修饰静态方法,默认为Class类的对象
        public static synchronized  void GetTicket(){
        
            if (count > 0) {
        
                System.out.println(Thread.currentThread().getName() + ":" + count);
                count--;
            }
        }
    }

package Thread;
    
    public class TicketThread2 implements Runnable{
        
    
         int count = 10;
        @Override
        public void run() {
        
            while(true){
        
                if(count<=0){
        
                    break;
                }
                try {
        
                    GetTicket();
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
        public   synchronized  void GetTicket() throws InterruptedException {
        
            if (count > 0) {
        
                System.out.println(Thread.currentThread().getName() + ":" + count);
                count--;
            }
        }
    }

### (2) LOCK锁 ###

Lock是java中提供的一个接口，下面有许多实现类，这里只说ReentrantLock, ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁  
ReentrantLock实现加锁和释放锁不像synchronized那样会自动释放，而是需要我们自己手动调用方法加锁，释放锁

package Thread;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class TicketThread3 extends Thread{
        
        int count = 10;
        static Lock lock = new ReentrantLock();
        @Override
        public void run() {
        
            while(true){
        
                try {
        
                    lock.lock();
                    if(count<=0){
        
                        break;
                    }
                    GetTicket();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }finally(
                lock.unlock();
            }
        }
        public void GetTicket() throws InterruptedException {
        
            if (count > 0) {
        
                System.out.println(Thread.currentThread().getName() + ":" + count);
                count--;
            }
        }
    
    }

加锁:调用lock()方法  
释放锁:调用unlock()方法，注意释放锁时将语句写到finally中保证真的释放了

## 十二.死锁 ##

死锁就是A想要打开B的锁，但B的锁被B占用，B想要打开A的锁，但A的锁被A占用着，两者相互牵制，彼此限制，就像中国人吃饭用一双筷子，外国人吃饭是一个刀子一个叉子，现在中国人变成了一根筷子和一把刀子，外国人变成了一根筷子和一把叉子，导致都不能吃饭，这就是死锁

package Thread.SS;
    
    public class SS extends Thread{
        
        boolean flag;
        static Object objA = new Object();
        static Object objB = new Object();
    
        public SS(boolean flag) {
        
            this.flag = flag;
        }
    
        @Override
        public void run() {
        
            if(flag){
        
                synchronized (objA){
        
                    System.out.println("objA");
                    synchronized (objB){
        
                        System.out.println("objB");
                    }
                }
            }
            else{
        
                synchronized (objB){
        
                    System.out.println("else objB");
                    synchronized (objA){
        
                        System.out.println("else objA");
                    }
                }
            }
        }
    }

package Thread.SS;
    public class SSTest {
        
        public static void main(String[] args) {
        
            SS ss1 = new SS(true);
            SS ss2 = new SS(false);
            ss1.start();
            ss2.start();
        }
    }

发生死锁时不会报错也不会异常，只会一直阻塞导致程序无法继续向下执行

## 十三.线程通信 ##

### (1)什么是线程通信 ###

==线程通信:==指的是线程之间彼此相互牵制，相互调度，即线程间的相互作用

### (2)线程通信中常用的三种方法 ###

wait():一旦执行此方法，线程会进入阻塞状态，并释放同步锁  
notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。  
notifyAll():一旦执行此方法，就会唤醒所有被wait的线程

注意:  
1.上述三个方法必须在同步代码块或者同步方法中调用，否则会异常  
2.上述三个方法都是在Object类中，但调用时必须用同步对象调用

## 十四.创建线程的第三种方式 ##

我们上述两种创建线程的方法都没有返回值，不能抛出异常，不支持泛型，所以为了更加方便我们引入了第三种创建线程的方式，即实现Callable接口

通过实现Callable接口中的call方法，来实现线程要执行的任务，再通过FutureTask类的构造方法，将callable包装起来，再将FutureTask对象传入Thread的构造方法中，Thread的构造方法只允许传入Runnable的对象，这是因为FutureTask实现了RunnableFuture接口，而RunnableFuture接口继承了Runnable类，所以FutureTask就间接继承了Runnable

package Thread.SS;
    
    import java.util.concurrent.Callable;
    
    public class RunTask implements Callable<Integer> {
        
        @Override
        public Integer call() throws Exception {
        
            int sum = 0;
            for(int i=1;i<=100;i++)
            {
        
                sum+=i;
            }
            return sum;
        }
    }

package Thread.SS;
    
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    public class RunTaskTest {
        
        public static void main(String[] args) {
        
            RunTask runTask = new RunTask();
            // FutureTask继承了RunnableFuture,RunnableFuture又继承了Runnable
            FutureTask<Integer> futureTask = new FutureTask<>(runTask);
            java.lang.Thread thread1 = new java.lang.Thread(futureTask);
            thread1.start();
            Integer integer = null;
            try {
        
                integer = futureTask.get();
            } catch (InterruptedException e) {
        
                throw new RuntimeException(e);
            } catch (ExecutionException e) {
        
                throw new RuntimeException(e);
            }
            System.out.println(integer);
        }
    }

[9cde893186ed403db5352f223527e31e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/b5c7e5faa97b4e83850c6b07d7c0a7d2.png