day25死锁&线程间通信&线程组&线程池（实现多线程的第三种方式：实现Callable接口）&定时器

最新推荐文章于 2022-11-15 18:06:36 发布

qnmdlzg

最新推荐文章于 2022-11-15 18:06:36 发布

阅读量103

点赞数

文章标签：死锁线程通信线程池定时器同步机制

本文链接：https://blog.csdn.net/qnmdlzg/article/details/123055717

版权

死锁：
指的是两个或者两个以上线程在执行过程中，因为争夺资源产生的一种互相等待的现象。死锁的现象更容易出现在同步嵌套的情况下，所以今后开发的时候，尽量避免同步嵌套

package com.shujia.wyh.day25;

public class DieLockDemo {
    public static void main(String[] args) {
        //创建两个线程对象
        DieLock d1 = new DieLock(true);
        DieLock d2 = new DieLock(false);

        //启动线程
        d1.start();
        d2.start();

    }
}

class DieLock extends Thread{

    private boolean flag;

    public DieLock(boolean flag){
        this.flag = flag;
    }


    /**
     *      现象1：
     *          if lock1
     *          else lock2
     *
     *      现象2：
     *          else lock2
     *          if lock1
     */
    @Override
    public void run() {
        if(flag){
            synchronized (MyLock.lock1){
                System.out.println("if lock1");
                synchronized (MyLock.lock2){
                    System.out.println("if lock2");
                }
            }
        }else {
            synchronized (MyLock.lock2){
                System.out.println("else lock2");
                synchronized (MyLock.lock1){
                    System.out.println("else lock1");
                }
            }

        }

    }
}

线程间通信

分析：
共享数据：同一个学生对象Student
生产者：SetThread 给学生对象的成员变量进行赋值操作
消费者：GetThread 获取学生对象的成员变量的值
测试类：StudentDemo 创建两个线程，一个设置值线程，一个获取值线程

注意：1、在外界创建出来一个学生对象，通过参数的形式让两个线程操作同一个对象

2、加锁解决线程安全问题

3、添加等待唤醒机制，解决生产者消费者的问题（同一条数据，连续消费了很多次）
void notify()
唤醒正在等待对象监视器的单个线程。
void notifyAll()
唤醒正在等待对象监视器的所有线程。
void wait()
导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法

为什么wait(),notify(),notifyAll()等方法都定义在Object类中

同步代码块的锁对象是任意对象，类型无法确定，所以这些方法都定义在Object类中，因为Java所有的类都有一个共同父类Object

package com.shujia.wyh.day25.demo3;

public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();


        SetThread setThread = new SetThread(s);
        GetThread getThread = new GetThread(s);

        //使用Thread类创建线程对象，将自定义对象作为参数传递
        Thread proThread = new Thread(setThread);
        Thread cusThread = new Thread(getThread);


        //启动线程
        proThread.start();
        cusThread.start();
    }

}

class Student {
    String name;
    int age;
    boolean flag;
}

class SetThread implements Runnable {
    private Student s;

    private int i = 0;


    SetThread(Student student) {
        s = student;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (s){
                //判断学生对象有没有值
                //flag初始的时候值是false,表示没有值，如果是true表示生产者已经生产了值
                //有值对于生产者来说，等待消费者消费数据
                if(s.flag){
                    try {
                        s.wait(); // 阻塞，等待消费者消费数据，才能继续往下走
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                if (i % 2 == 0) {
                    s.name = "小王";
                    s.age = 18;
                } else {
                    s.name = "小张";
                    s.age = 19;
                }
                i++;

                //生产者生产完数据后，将flag值改为true
                //通知消费者消费数据
                s.notify();
                s.flag = true;
            }

        }

    }

}

class GetThread implements Runnable {
    private Student s;

    GetThread(Student student) {
        s = student;
    }

    @Override
    public void run() {
        while (true){
            synchronized (s){
                //判断学生对象的成员变量是否有值
                //如果flag的值是true，表示可以进行取值，反之，等待生产者生产数据
                if(!s.flag){
                    try {
                        s.wait(); //阻塞 等待生产者生产数据
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                System.out.println(s.name + "---" + s.age);

                //消费者消费完数据后，通知生产者生产数据
                s.notify();
                s.flag = false;
            }
        }

    }
}

线程组：
Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制

public final String getName()返回此线程组的名称

Thread(ThreadGroup group, Runnable target, String name)
分配一个新的 Thread对象，使其具有 target作为其运行对象，具有指定的 name作为其名称，属于 group引用的线程组

ThreadGroup(String name)构造一个新的线程组

package com.shujia.wyh.day25;

public class ThreadGroupDemo {
    public static void main(String[] args) {
        //创建自定义对象
        MyRunnable myRunnable = new MyRunnable();

        //通过Thread类创建的多个线程对象
        Thread t1 = new Thread(myRunnable,"小王");
        Thread t2 = new Thread(myRunnable,"小张");

        //默认情况下，所有的线程都属于主线程组。
        //public final ThreadGroup getThreadGroup()
        ThreadGroup tg1 = t1.getThreadGroup();
        System.out.println(tg1);
        ThreadGroup tg2 = t2.getThreadGroup();
        System.out.println(tg2);

        //如何线程组的名字
        //public final String getName()返回此线程组的名称。
        String s1 = tg1.getName();
        String s2 = tg2.getName();

        //需求：给线程分组
        //构造一个新的线程组。
        ThreadGroup tg3 = new ThreadGroup("帅哥组");

        //创建线程对象并分组
        Thread t3 = new Thread(tg3, myRunnable, "小李");
        Thread t4 = new Thread(tg3, myRunnable, "小虎");
        Thread t5 = new Thread(tg3, myRunnable, "小刘");

        //获取到目前位置所有线程的名字以及所属线程组的名字
        System.out.println(t1.getName()+"属于线程组："+t1.getThreadGroup().getName());
        System.out.println(t2.getName()+"属于线程组："+t2.getThreadGroup().getName());
        System.out.println(t3.getName()+"属于线程组："+t3.getThreadGroup().getName());
        System.out.println(t4.getName()+"属于线程组："+t4.getThreadGroup().getName());
        System.out.println(t5.getName()+"属于线程组："+t5.getThreadGroup().getName());

        //Java允许程序直接对线程组进行控制。
        //需求：将一个组内的所有线程设置为守护线程
        //直接通过组名进行设置，组里面的线程都是属于守护线程
        tg3.setDaemon(true);
    }
}

线程池：
程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。
而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。
线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用

public static ExecutorService newFixedThreadPool(int nThreads)

Future<?> submit(Runnable task)
提交一个可运行的任务执行，并返回一个表示该任务的未来

void shutdown()
启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。

package com.shujia.wyh.day25;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(2);

        //Future<?> submit(Runnable task)
        //提交一个可运行的任务执行，并返回一个表示该任务的未来。
        //提交即运行
        MyRunnable myRunnable = new MyRunnable();
        pool.submit(myRunnable); //底层封装成了一个线程对象并启动执行
        pool.submit(myRunnable);
        //提交的线程数超过线程池的数量也会执行，只不过是当有空闲线程位置的时候再去执行
        pool.submit(myRunnable);

        //void shutdown()
        //启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。
        pool.shutdown();

    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 200; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

实现多线程的第三种方式：
自定义类实现Callable接口，实现call方法，该线程的启动必须与线程池结合，单独无法创建线程对象启动

<T> Future<T> submit(Callable<T> task)
提交值返回任务以执行，并返回代表任务待处理结果的Future

package com.shujia.wyh.day25;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Callable;

public class ThreadPoolDemo2 {
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(2);

        //创建自定义Callable对象
        MyCallable myCallable = new MyCallable();

        //提交到线程池中执行
        pool.submit(myCallable);

        //手动停止线程池
        pool.shutdown();

    }
}

class MyCallable implements Callable {
    @Override
    public Object call() throws Exception {
        Object o = new Object();

        for (int i = 1; i <= 200; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }

        return o;
    }
}

匿名内部类的形式创建线程对象

package com.shujia.wyh.day25;

public class ThreadDemo2 {
    public static void main(String[] args) {
        //1、继承Thread类，重写run方法，start()启动线程
        new Thread("小王") {
            @Override
            public void run() {
                for (int i = 1; i <= 200; i++) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }.start();

        //2、实现Runnable接口，实现run方法
        new Thread(new Runnable(){
            @Override
            public void run() {
                for (int i = 1; i <= 200; i++) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        },"小虎").start();


    }
}

定时器Timer：是一个应用十分广泛的线程工具，可用于调度多个定时任务以后台线程的方式执行。在Java中，可以通过Timer和TimerTask类来实现定义调度的功能

public Timer()

public void schedule(TimerTask task, long delay) 在指定的延迟之后安排指定的任务执行

public void schedule(TimerTask task,long delay,long period) 固定延迟执行的指定任务，然后在指定的延迟之后开始，重新执行

TimerTask public abstract void run() 静态方法需要自定义类重写方法调用

package com.shujia.wyh.day25;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Timer;
import java.util.TimerTask;

public class TimerDemo2 {
    public static void main(String[] args) {
        //创建定时器对象
        Timer timer = new Timer();

        //void schedule(TimerTask task, long delay, long period)
        //在指定 的延迟之后开始 ，重新执行 固定延迟执行的指定任务。
        //3秒后执行任务，并且之后每隔两秒执行一次
        timer.schedule(new MyTask2(),3000,2000);
    }
}

class MyTask2 extends TimerTask{

    @Override
    public void run() {
        try {
            FileReader fr = new FileReader("ss.txt");
            BufferedReader br = new BufferedReader(fr);
            String s = br.readLine();
            System.out.println(s);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

qnmdlzg

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day25死锁&线程间通信&线程组&线程池（实现多线程的第三种方式：实现Callable接口）&定时器

死锁：指的是两个或者两个以上线程在执行过程中，因为争夺资源产生的一种互相等待的现象。死锁的现象更容易出现在同步嵌套的情况下，所以今后开发的时候，尽量避免同步嵌套package com.shujia.wyh.day25;public class DieLockDemo { public static void main(String[] args) { //创建两个线程对象 DieLock...
复制链接

扫一扫

day25死锁&线程间通信&线程组&线程池（ 实现多线程的第三种方式：实现Callable接口）&定时器

day25死锁&线程间通信&线程组&线程池（实现多线程的第三种方式：实现Callable接口）&定时器