线程创建，线程通信，线程安全

谁借莪１个温暖的怀抱￠ 2023-10-10 15:53 74阅读 0赞

## 单线程 ##

线程是一个内部程序的一条执行路径。

我们之前执行的main路程就是一条执行线程

程序中只有一条执行的线程就是单线程的。多线程，反之亦然

## 多线程创建方式 ##

多线程的创建的方式：

1.   *  继承自Thread
     *  实现Runnable接口
     *  Jdk 5.0 增加了：实现Callable接口
2.  1.  定义一个子类继承自Thread,重写run() 方法，定义线程任务
    2.  创建子类对象
    3.  调用对象的start()方法，启动线程（启动后还是执行run()方法的代码）

为什么不直接调用run()方法要调用start()方法?

> 直接调用run方法会变成普通方法，此时相当于还是单线程
> 
> 只有调用start()方法才是启动一个新的线程
> 
> 不能把主线程放在子线程前面这样相当于一个单线程的效果，这样会优先执行主线程

实现接口

### 继承实现多线程 ###

实现线程步骤

1.  在run()方法中编写线程任务，继承线程类
2.  在测试类中先创建线程任务类的对象，将该对象给线程对象
3.  创建线程对象
4.  调用start() 启动线程

package com.pan.crizab;
    //缺点较多，不便于扩展接口任务对象的功能
    public class ThreadExtend extends Thread {
        
        public void run(){
        
            System.out.println("通过继承的方式实现线程的任务");
        }
    }
    class Main{
        
        public static void main(String[] args) {
        
            //1.创建线程任务对象
            ThreadExtend threadExtend = new ThreadExtend();
            //2.创建线程对象
            Thread thread1 = new Thread(threadExtend);
            thread1.start();
        }
    }

缺点：不便于扩展，不能处理结果集

### 实现runnable接口方式 ###

实现线程步骤

1.  实现接口Runnable,在run()方法中编写线程任务
2.  在测试类中先创建线程任务类的对象，将该对象给线程对象
3.  创建线程对象
4.  调用start() 启动线程

package com.pan.crizab;
    //便于扩展，但是不能处理返回要求
    public class RunnableImp extends Thread implements Runnable{
        
        @Override
        public void run() {
        
            System.out.println("通过实现runnable接口实现线程任务");
        }
    }
    
    class Main1{
        
        public static void main(String[] args) {
        
            //1.多态式创建接口实现类线程任务对象
            Runnable runnable1 = new RunnableImp();
            //2.创建线程，将线程任务对象传入线程
            Thread thread1 = new Thread(runnable1);
            //3.启动线程
            thread1.start();
        }
    }

缺点：不能处理线程任务的返回值，没有结果返回

优点：扩展性强，在实现接口的同时可以继承其他的类，完成一些方法的重写

### 实现Callable函数式接口 ###

Callable类有

实现线程步骤

1.  实现callable接口，在run()方法中编写线程任务
2.  将线程任务对象给FutureTask对象进行修饰包装
    
    1.  FutureTask类是继承自runnable类，也就是其本质还是Runnable接口只是实现了返回结果的处理
3.  在测试类中先创建线程任务类的对象，将给对象给线程对象
4.  创建线程对象
5.  调用start() 启动线程
6.  使用futureTask对象调用get获取结果返回

package com.pan.crizab;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    public class CallableImp {
        ， 
        public static void main(String[] args) {
        
            //创建线程任务对象
            Callable callable = new CallableIm(100);
            //封装该对象，使之可以在线程对象中入参，以便后面调用get（）方法获取返回值
            FutureTask<Object> f1 = new FutureTask<Object>(callable);
            Thread t1 = new Thread(f1);
            t1.start();
    
            try {
        
                int s = (Integer) f1.get();
                System.out.println("f1执行后的结果"+s);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            } catch (ExecutionException e) {
        
                e.printStackTrace();
            }
    
            //创建线程任务对象
            Callable callable2 = new CallableIm(100);
            //封装该对象，使之可以在线程对象中入参，以便后面调用get（）方法获取返回值
            FutureTask<Object> f2 = new FutureTask<Object>(callable);
            Thread t2 = new Thread(f2);
            t2.start();
    
            try {
        
                int s = (Integer) f2.get();
                System.out.println("f2执行后的结果"+s);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            } catch (ExecutionException e) {
        
                e.printStackTrace();
            }
        }
    }
    
    
    class CallableIm implements Callable<Object>{
        
        private int n;
    
        public CallableIm(int n) {
        
            this.n = n;
        }
    
        @Override
        public Object call() throws Exception {
        
            int sum = 0;
            for(int i = 0;i<n;i++){
        
                sum +=  i;
            }
            System.out.println("线程执行任务");
            return sum;
        }
    }

缺点：代码量过多

优点：便于扩展，便于处理结果的返回值，

### 线程常用API ###

区分各个线程：setName(String name),getName();

sleep();

wait()

notifyAll()；

在许多的线程中，创建当前的线程对象

## 线程安全问题 ##

多个线程同时操作一个共享资源的时候可能会出现业务安全问题，称为线程安全问题

**详解：**

> 银行取钱：
> 
> 小红与小白拥有一个共同账户，余额10万元
> 
> 小红和小白同时取钱10万元
> 
> 线程并发执行，此时都判断都为可以取出，则同时取出10万元
> 
> 出现余额为-10万余元的问题

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iVZn04CW-1672539577713)(D:\\HONOR Magic-link\\Screenshot\\capture\_20221230210642785.bmp)\]

**解决办法：也就是加锁，对资源区加锁**

**synchronized**

*  代码块形式
    
    其中 this 就是账户类的对象，用于指定访问时的线程
    
        synchronized (this){
              
            //代码
        }
 *  方法修饰形式
    
        //同步方法锁
            public synchronized void drawMoney(double money){
              
                //获取用户的Id()
                String name =  Thread.currentThread().getName();
        		//lock.lock();
                    if(this.money >= money){
              
                        System.out.println(""+name+"来取钱,取出"+money );
                        this.money -= money;
                        Thread.sleep(5000);
                        System.out.println("余额："+ this.money);
                    }
                    else{
              
                        System.out.println(name+"来取钱"+money);
                        System.out.println("余额不足");
                    }
                //lock.unlock();
            }

**Lock**:

//防止中途出现异常，迟迟不释放资源区

所以当出现异常时，也要执行完 unlock();

lock();

unlock();

finally{
        
        lock1.unlock();
    }

账户类

package com.pan.items;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class Account {
        
        private String carId;
        private Double money;
        //创建Lock锁的实现类对象
        private final Lock lock = new ReentrantLock();
    
        public Account(String carId, Double money) {
        
            this.carId = carId;
            this.money = money;
        }
        //同步方法锁
        public synchronized void drawMoney(double money){
        
            //获取用户的Id()
            String name =  Thread.currentThread().getName();
    //        lock.lock();
            //存钱
                if(this.money >= money){
        
                    System.out.println(""+name+"来取钱,取出"+money );
                    this.money -= money;
                    System.out.println("余额："+ this.money);
                }
                else{
        
                    System.out.println(name+"来取钱"+money);
                    System.out.println("余额不足");
                }
            //lock.unlock();
    
        }
    
        public String getCarId() {
        
            return carId;
        }
    
        public void setCarId(String carId) {
        
            this.carId = carId;
        }java
    
        public Double getMoney() {
        
            return money;
        }
    
        public void setMoney(Double money) {
        
            this.money = money;
        }
    }

线程任务类：

package com.pan.items;
    
    public class RunnableDemo extends Thread implements Runnable {
        private Account account;
    
    
        public RunnableDemo(String name, Account account) {
            super(name);
            this.account = account;
        }
    
        @Override
        public void run() {
            account.drawMoney(100000.0);
        }
    }

执行测试类：

package com.pan.items;
    
    public class Main1 {
    
        public static void main(String[] args) {
            Account account = new Account("123ID",100000.0);
           new RunnableDemo("小红",account).start();
           new RunnableDemo("小白",account).start();
    
        }
    
    }

结果如下

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l6FsgKuk-1672539577716)(C:\\Users\\abundan\\AppData\\Roaming\\Typora\\typora-user-images\\image-20221230210537496.png)\]

## 线程通信 ##

**详解**

> 线程通信就是各个线程之间共享信息，操作同一个资源区，各个线程可以接收来自不同线程所共享的数据，根据数据信息抢占资源或者暂停资源的夺取。
> 
> eg:
> 
> 五个人共享一个账户，账户：资源区。五个人：五个线程
> 
> 三人负责存钱，两人负责取钱
> 
> 但同一时间只能有一个人可以操作该账户，所以抢到资源后就要停止他们的争夺，就会用到通信的API
> 
> wait()，notifyAll()，

如下代码实现

public synchronized void drawMoney(double money) throws Exception {
            //获取用户的Id()
            String name =  Thread.currentThread().getName();
    //        lock.lock();
                if(this.money >= money){
                    System.out.println(""+name+"来取钱,取出"+money );
                    this.money -= money;
                    System.out.println("余额："+ this.money);
                    this.notifyAll();
                    this.wait();
                }
                else{
                    System.out.println(name+"来取钱"+money);
                    System.out.println("余额不足,通知存钱");
                    this.notifyAll();
                    this.wait();
                }
            //lock.unlock();
    
        }
    
        public synchronized void saveMoney(double v) throws Exception {
            String name = Thread.currentThread().getName();
            if (this.money == 0){
                System.out.println(name+"来存钱同时通知其他线程取钱,存钱数量："+v);
                this.money += v;
                Thread.sleep(5000);
                this.notifyAll();
                this.wait();
            }else {
                System.out.println(name+"查询=====================还有钱，余额："+money);
                this.notifyAll();
                this.wait();
            }
    
        }