华杉研发九学习日记24 线程同步 死锁 线程通信 线程池 Callable接口

华杉研发九学习日记24

java多线程

一，线程同步

1.1 线程同步问题

多个线程同时操作一个全局数据或静态数据时可能会造成数据冲突

解决：

• synchronized同步代码块
• synchronized同步方法
• 使用锁对象加锁解锁

//  火车站卖车票  --  100张
public class Train implements Runnable{
    int count = 100;    //一百张火车票，全局变量
    private boolean flag = true;
    @Override
    public void run() {
        while(flag){    //  永久开启窗口售卖火车票
            sale();
        }
    }
    public void sale(){
        //  设置一个停止售卖的条件
        if(count<=0){
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName()+ "窗口售出了第"+count+"张火车票！");
        count--;
    }
}

public class TestTrain {
    public static void main(String[] args) {
        //  创建火车票对象
        Train train = new Train();
        //  启动线程
        new Thread(train,"窗口一").start();
        new Thread(train,"窗口二").start();
        new Thread(train,"窗口三").start();
    }
}
//	测试结果卖出票会出现重复和顺序混乱等问题

1.2 同步代码块

Java中采用锁来保护共享资源，防止数据不一致的情况产生。下面我们就来介绍Java中的同步机制以及synchronized关键字。

在Java中，每个对象都拥有一个"互斥锁标记"，这就好比是我们说的挂锁。这个锁标记，可以用来分给不同的线程。之所以说这个锁标记是"互斥的"，因为这个锁标记同时只能分配给一个线程。

光有锁标记还不行，还要利用synchronized 关键字进行加锁的操作。

synchronized 关键字有两种用法

第一种: synchronized+代码块。

synchronized(obj){

	代码块;

}

synchronized关键字后面跟一个圆括号，括号中的是某一个引用，这个引用应当指向某一个对象。后面紧跟一个代码块，这个代码块被称为同步代码块""。
这种语法的含义是，如果某一个线程想要执行代码块中的代码，必须要先获得obj所指向对象的互斥锁标记。也就是说，如果有一个线程t1要想进入同步代码块，必须要获得obj对象的锁标记;而如果t1线程正在同步代码块中运行，这意味着t1有着obj对象的互斥锁标记;而这个时候如果有一个t2线程想要访问同步代码块，会因为拿不到obj 对象的锁标记而无法继续运行下去。

public void sale(){
    synchronized (object){//  设置一个停止售卖的条件
        if (count <= 0) {
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName() + "窗口售出了第" + count + "张火车票！");
        count--;
    }
}

1.3 同步方法

public synchronized void sale(){
    if (count <= 0) {
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName() + "窗口售出了第" + count + "张火车票！");
        count--;
}

1.4 使用锁对象

    private Lock lock = new ReentrantLock();//	创建锁对象
//  使用锁对象上锁
public void sale(){
    lock.lock();    //  上锁
    if (count <= 0) {
        flag = false;
        lock.unlock();  //  解锁
        return;
    }
    System.out.println(Thread.currentThread().getName() + "窗口售出了第" + count + "张火车票！");
    count--;
    lock.unlock();  //  解锁
}

二，死锁

如果同步代码块包裹多层时，可能会产生新的问题

(a等待b释放，b等待a释放)

synchronized(a){
    synchronized(b){
        代码块；
    }
}
synchronized(b){
    synchronized(a){
        代码块；
    }
}

解决死锁：

在Java中。采用了wait和notify这两个方法，来解决死锁机制。
首先，在Java中，每一个对象都有两个方法: wait和notify方法。这两个方法是定义在Object类中的方法。对某个对象调用wait(方法，表明让线程暂时释放该对象的锁标记。

synchronized(a){
    a.wait();
    synchronized(b){
        代码块；
    }
}
synchronized(b){
    synchronized(a){
        代码块；
        a.notify();
    }
}

由于可能有多个线程先后调用a对象 wait方法，因此在a对象等待状态中的线程可能有多个。而调用a.notify()方法，会从a对象等待状态中的多个线程里挑选一个线程进行唤醒。与之对应的，有一个notifyAll)方法，调用a.notifyAll会把a对象等待状态中的所有线程都唤醒。

wait作用是让当前线程阻塞，阻塞多久，取决于有没有其他线程唤醒它。notify作用是唤醒处于wait状态的线程。必须是同一个监视器下的线程。
notifyAll作用是唤醒所有处于wait状态的线程。必须是同一个监视器下的线程。

三，线程通信

不同线程之间可以相互的发信号。这就是线程通信。之所以需要进行线程通信，是因为有些时候，一个线程的执行需要依赖另外一个线程的执行结果。在结果到来之前，让线程等待(wait)，有了结果只之后再进行后续的操作。对于另外一个线程而言，计算完结果，通知(notify)一下处于等待状态的线程.

线程通信借助的是Object类的wait,notify,notifyAll方法。

wait作用是让当前线程阻塞，阻塞多久，取决于有没有其他线程唤醒它。

notify作用是唤醒处于wait状态的线程。必须是同一个监视器下的线程。

notifyAll作用是唤醒所有处于wait状态的线程。必须是同一个监视器下的线程。

一般情况下，多线程里会出现线程同步的问题，我们不但要进行线程通信，还要解决线程同步的问题。

wait 与notify应用:生产者-消费者模式
这是一个比较经典的多线程场景。有商品的时候，消费者才可以消费，没有商品的时候，消费者等待。商品库存充足的时候，生产者等待，库存不满的时候，生产者生产商品。

四，线程池

什么是线程池?

水池:存放水的池子。线程池:存放线程的池子。

Java中的线程池:是一个管理线程的池子。可以在需要的时候开辟线程，可以控制最大开辟的线程个数，可以在不需要的时候关闭线程，可以让任务排队执行。这些管理过程不需要我们干预，线程池能帮我们完成。我们所要做的就是往线程池中放任务。
为什么要有线程池?

多线程解决了任务并发问题，但是开辟和关闭线程很消耗系统的性能，开辟和关闭一个线程要处理很多细节，频繁的开辟和关闭线程会给系统增加很多开销。

线程池使用了重用的概念，可以控制线程开辟的数量，复用这些线程执行任务。这样就不用频繁的开辟和关闭线程了。

线程池使用场景及优势
线程池适合处理的任务:执行时间短、工作内容较为单一。

合理使用线程池带来的好处:
1）降低资源消耗：重复利用已创建的线程降低线程创建和销毁造成的开销

​ 2）提高响应速度：当任务到达时。任务可以不用等待线程创建就能立即执行

​ 3）提高线程的可管理性：可以统一对线程进行分配、调优和监控

​ 4）提供更多强大的功能：线程池具备可拓展性，允许开发人员向其中增加更多的功能。比如延时定时线程池SchedulerThreadPoolExecutor，允许任务延期执行或定期执行

线程池的作用包括:
1)：利用线程池管理并复用线程、控制最大并发数等

​ 2)：实现任务线程队列缓存策略和拒绝机制
​

​ 3)：实现某些与时间相关的功能。如定时执行、周期执行

​ 4)∶隔离线程环境。通过配置两个或多个线程池，将一台服务器上较慢的服务和其他服务隔离开，避免各服务线程相互影响。

三种常见的线程池

• 固定线程个数的线程池
• 不限线程个数的线程池
• 单个线程的线程池（串行任务池）

public static void main(String[] args) {
    //  创建线程池
    ExecutorService es = Executors.newFixedThreadPool(2);
    //  提交任务    --  把任务提交给线程池，让其从线程池中获取一个线程，并执行其当前任务
    es.submit(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"你好");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    });
    es.submit(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"哟西");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    });
    es.submit(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"你好");
        }
    });
    //  关闭资源
    es.shutdown();
}

拷贝：

public class TestCopy {
    public static void main(String[] args) {
        //  1.创建线程池
        ExecutorService es = Executors.newFixedThreadPool(3);
        //  2.找到其文件夹遍历其中的文件。如果是文件，则把拷贝的任务提交给战程法
        File file = new File("C:\\Users\\86155\\Videos\\Counter-strike 2");
        File[] files = file.listFiles();
        for (File f : files) {
            if (f.isFile()) {
                //  把拷贝的任务交给线程池
                es.submit(new Runnable() {
                    @Override
                    public void run() {
                        try(BufferedInputStream fis = new BufferedInputStream(new FileInputStream(f));
                            BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("C:\\Users\\86155\\Desktop\\张晓岚\\aa\\"+f.getName()))
                        ) {
                            byte[] buffer = new byte[1024];
                            int len;
                            while ((len = fis.read(buffer)) != -1) {
                                fos.write(buffer, 0, len);
                            }

                        } catch (FileNotFoundException e) {
                            throw new RuntimeException(e);
                        } catch (IOException e) {
                            throw new RuntimeException(e);
                        }
                    }
                });
            }
        }
        es.shutdown();

    }
}

五，Callable接口

创建步骤;
1.创建一个子类，实现Callable接口

​ 2.重写其中的call方法

​ 3.创建EgtrueTask对象，封装Callable对象

​ 4.创建Thread对象，封装FutureTask对象

​ 5.使用start来启动线程

public class MyCall implements Callable {
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("------"+i);
        }
        return 100;
    }
}

public class TestMyCall {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //  实现Callable接口方式
        MyCall myCall = new MyCall();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(myCall);
        new Thread(futureTask).start();
        System.out.println(futureTask.get());// 打印线程执行后返回的结果数据

        //  主线程
        for (int i = 0; i < 100; i++) {
            System.out.println("====="+i);
        }
    }
}