1.java 线程常用工具类

最新推荐文章于 2021-08-31 15:59:14 发布

蚂蚁@叔叔

最新推荐文章于 2021-08-31 15:59:14 发布

阅读量322

点赞数

分类专栏： 01-线程-初

原文链接：https://www.jianshu.com/p/757c4aed2647

版权

01-线程-初专栏收录该内容

16 篇文章 1 订阅

订阅专栏

一 Timer 定时器

Timer 类主要是用来完成定时任务的功能，比如闹钟这种周期性变化的事物。

1 一个最简单的定时器

两秒钟后引爆一个定时炸弹。

    @Test
    public void test() {
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("定时器爆炸");
            }
        },
        2000);//延迟两秒执行任务
    }

2 设置一个周期性执行的闹钟

两秒钟后引爆一个炸弹，以后每过一秒引爆一个

    @Test
    public void test2() {
        new Timer().schedule(new TimerTask() {
                                 @Override
                                 public void run() {
                                     System.out.println("定时器爆炸");
                                 }
                             },
                2000,
                1000);//第二次及以后会每过1000ms执行一次任务。
    }

注意：如果我们要执行一个任务时，想要手动的去取消该任务，那么我们可以使用 cancel()方法来取消。

在 Timer 类中的作用是将任务队列中的全部任务都取消（一个 Timer 可以创建多个 TimerTask 任务）
在 TimerTask 类中的作用是将自身任务从任务队列中取消

二 ThreadLocal的使用

ThreadLocal 是一个创建线程局部变量的类。通常我们在创建一个变量的时候，该变量是可以被任何线程所访问的。而使用 ThreadLocal 类创建的变量只能被创建变量的那个线程所访问，其它线程访问不到。

** 一个简单的例子**

public class _6_ThreadLocal {
    @Test
    public void test() {
        ThreadLocal<String> local = new ThreadLocal<>();
        for (int i = 0; i < 5; ++i) {
            final int index = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (_6_ThreadLocal.class){
                        System.out.println("当前线程：" + index);
                        local.set("线程" + index + "的数据");
                        System.out.println(local.get());
                    }
                }
            }).start();
        }

    }
}

三 ThreadPool 线程池

ThreadPool 就相当于是一个处理任务的线程工厂，工厂内有很多线程（工人），每当有任务来的时候，线程就去执行任务，任务结束后线程（工人）就休息。

使用ThreadPool 是为了提高程序的吞吐能力，提高CPU的利用效率。线程池就好比是一个医院，最初医院会招聘固定数量的医生（线程池的容量），当有患者来看病时，医生就会去诊断患者，当所有的医生都很忙碌时，医院就会招聘额外的医生，当患者减少时，医院救会解聘那些额外招来的医生。

医生看病的简单例子

public class _7_ThreadPool {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(3);//创建固定的线程池
//        ExecutorService threadPool = Executors.newCachedThreadPool();//创建自适应线程池 随任务的数量变化
//        ExecutorService threadPool = Executors.newSingleThreadExecutor();//创建单一线程池
        for(int i = 0; i < 10; ++i) {
            final int index = i;
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程" + Thread.currentThread().getName() + "正在诊疗第" + index + "个患者");
                }
            });
        }
    }
}

四 Lock

Lock 比传统线程中的 synchronized 更加面向对象，更加方便。使用lock想要达到线程互斥的效果需要多个线程执行的代码块必须要用同一个 Lock对象。
读写锁：分为读锁和写锁，多个读锁之间不互斥，读锁和写锁之间互斥，写锁和写锁之间也互斥。

1 一个简单锁的例子

两个线程不断的输出各自的字符串，保证每个线程每次输出字符串的完整性。

public class _8_Lock {
    private static  Lock lock = new ReentrantLock();//创建锁
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    new Ouput().output("HHHHHHHHHH");
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    new Ouput().output("aaaaaaaaa");
                }
            }
        }).start();
    }

  static  class Ouput{
        public  void output(String name) {
            lock.lock();//加锁
            try {
                for(int i = 0; i < name.length(); ++i) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }finally {
                lock.unlock();//释放锁
            }
        }
    }
}

2 读写锁的例子

简单的缓存实现

public class _9_CacheDemo {
    private Map<String, Object> data = new HashMap<>();
    public static void main(String[] args) {
        System.out.println(new _9_CacheDemo().getData("haha").toString());
    }

    private ReadWriteLock rwl = new ReentrantReadWriteLock();
    public Object getData(String key) {
        Object value = null;
        rwl.readLock().lock();
        try {
            value = data.get(key);
            if (value == null) {
                rwl.readLock().unlock(); //如果缓存无数据，关闭 readLock ，打开 writeLock （1）
                rwl.writeLock().lock();
               try {
                   if (value == null) {//使用 if 判断 value， 避免多个线程同时进入到（1）重复写入
                       value = "hehe";
                   }
               }finally {
                   rwl.writeLock().unlock();
               }
            }
            rwl.readLock().lock();//打开 readLock 是为了 finally 中的 unLock
        }finally {
            rwl.readLock().unlock();
        }
        return value;
    }
}

五 Condition

Condition 将 Object 的 wait()、notify()、notifyAll()方法分解成不同的对象，以便更好的和 Lock 组合使用（必须结合使用）。Lock 替代了 synchronized ，Condition 也替代了 Obejct 所监视的方法。使用 Condition 的好处在于可以选择性的去唤醒其它的线程，比如有三个线程A、B和C，需要现执行B线程在执行A线程，最后执行C线程，如果使用 Condition便可以很好的解决。

一个阻塞队列的例子

public class _10_Condition {
    final Lock lock = new ReentrantLock();
    final Condition fullCondition = lock.newCondition();
    final Condition emptyCondition = lock.newCondition();

    final Object[] datas = new Object[10];
    int putIndex, takeIndex, count;

    public static void main(String[] args) {
        _10_Condition condition = new _10_Condition();

        //存数据线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 50; ++i) {
                    try {
                        Thread.sleep(new Random().nextInt(2000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    condition.put(i);
                }
            }
        }).start();
        //取数据线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 50; ++i) {
                    try {
                        Thread.sleep(new Random().nextInt(2000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    condition.get();
                }
            }
        }).start();
    }


    public void put(Object data) {
        lock.lock();
        try {
            while (count == datas.length) { //数组已满，阻塞 put
                System.out.println("the arrays is full");
                fullCondition.await();
            }
            datas[putIndex] = data;
            System.out.println(Thread.currentThread().getName() + " put the data-------> " + data);
            ++count;
            if (++putIndex == datas.length) {
                putIndex = 0;
            }
            emptyCondition.signal(); //数组中已有数据，唤醒 take 去数据
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public Object get() {
        lock.lock();
        try {
            while (count == 0) {   //数组为空，阻塞 take
                System.out.println("the arrays is empty");
                emptyCondition.await();
            }
            Object obj = datas[takeIndex];
            System.out.println(Thread.currentThread().getName() + " get the data " + obj);
            --count;
            if (++takeIndex == datas.length) {
                takeIndex = 0;
            }
            fullCondition.signal(); //数组没满，唤醒 put 存数据
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return null;
    }
}

六 Semaphore

Semaphore维护了当前访问的个数，提供同步机制，控制同时访问的个数。Semaphore和ThreadPool功能类似，但还是有区别的：

线程池控制的是线程数量，而信号量控制的是并发数量，虽然说这个看起来一样，但是还是有区别的。信号量的调用，当达到数量后，线程还是存在的，只是被挂起了而已。而线程池，同时执行的线程数量是固定的，超过了数量的只能等待。
线程池是线程复用的；信号量是线程同步的
线程池是多个线程异步执行任务，信号量是控制任务中的多线程同步区域。

小例子

10个线程，3个坑,每次可进去三个线程，其余的线程都等待，当有一个线程离开时，等待的线程才可以进入

public class _10_Semaphore {
    public static void main(String[] args) {
        Semaphore sp = new Semaphore(3);
        for(int i = 0 ; i < 10; ++i) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        sp.acquire();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"进入，当前有" + (3 - sp.availablePermits())+"个线程");
                    try {
                        Thread.sleep(new Random().nextInt(10000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"线程离开"+"，当前有" + (3 - sp.availablePermits())+"个线程");
                    sp.release();
                }
            }).start();
        }
    }
}

蚂蚁@叔叔

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
1.java 线程常用工具类

一 Timer 定时器Timer 类主要是用来完成定时任务的功能，比如闹钟这种周期性变化的事物。** 1 一个最简单的定时器**两秒钟后引爆一个定时炸弹。 @Test public void test() { new Timer().schedule(new TimerTask() { @Override ...
复制链接

扫一扫

专栏目录