java并发编程实战wwj———————-第一阶段————–27-28-29-30

java并发编程实战wwj———————-第一阶段————–27-28-29-30代码:chapter9sleep:是Threa的方法,sleep不释放锁,sleep不用synchronized,不需要被唤醒。wait:所有对象的方法,wait释放锁,用synchronized,要被唤醒。如何使用这个案例:切换m1和m2方法。packagechapter9;importjava.util.stream.Stream;/************…

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

代码:chapter9

java并发编程实战wwj----------------------第一阶段--------------27-28-29-30

sleep:是Thread的方法,sleep不释放锁,sleep不用synchronized,不需要被唤醒。

wait:所有对象的方法,wait释放锁java并发编程实战wwj----------------------第一阶段--------------27-28-29-30

用synchronized,要被唤醒。

java并发编程实战wwj----------------------第一阶段--------------27-28-29-30

如何使用这个案例:切换m1和m2方法。

chapter9


package one.chapter9;

import java.util.stream.Stream;


public class DifferenceOfWaitAndSleep {

    private final static Object LOCK = new Object(); // 定义锁一定要定义final类型的

    public static void main(String[] args) {
        Stream.of("T1", "T2").forEach(name ->
                new Thread(name) {
                    @Override
                    public void run() {
                        m1();
                    }
                }.start()
        );
    }

    public static void m1() {
        synchronized (LOCK) {
            try {  
                System.out.println("The Thread " + Thread.currentThread().getName() + " enter.");
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    public static void m2() {
        synchronized (LOCK) {
            try {
                System.out.println("The Thread " + Thread.currentThread().getName() + " enter.");
                LOCK.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

—————————————-27———–sleep和wait的区别——————-

先start之后才可以join。先设置守护线程才可以start。

java并发编程实战wwj----------------------第一阶段--------------27-28-29-30线程的数量的优化图,多了上下文就多了会有开销的。

卡了看看是不是线程太多了。

jdk8的::https://blog.csdn.net/csmans/article/details/82256690

问题:10000台机器如何用100个线程采集,线程多了会有问题,上下文切换。

代码:

java并发编程实战wwj----------------------第一阶段--------------27-28-29-30

package one.chapter9;

import java.util.*;

public class CaptureService {

    final static private LinkedList<Control> CONTROLS = new LinkedList<>();
    private final static int MAX_WORKER = 5;

    public static void main(String[] args) {

        List<Thread> worker = new ArrayList<>();
        Arrays.asList("M1", "M2", "M3", "M4", "M5", "M6", "M7", "M8", "M9", "M10").stream()
                .map(CaptureService::createCaptureThread)
                .forEach(t -> {
                    t.start();
                    worker.add(t);
                });
        // 在这里去通体的join
        worker.stream().forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Optional.of("All of capture work finished").ifPresent(System.out::println);
    }


    private static Thread createCaptureThread(String name) {
        return new Thread(() -> {
            Optional.of("The worker [" + Thread.currentThread().getName() + "] BEGIN capture data.")
                    .ifPresent(System.out::println);
            synchronized (CONTROLS) {
                while (CONTROLS.size() > MAX_WORKER) {//要是有5个就乖乖等着就可以
                    try {
                        CONTROLS.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                CONTROLS.addLast(new Control());//跳出while就说明可以跑了加入跑的队列  对公共数据操作要串行化保护的
            }

            // 这个是并行的
            Optional.of("The worker [" + Thread.currentThread().getName() + "] is working...")
                    .ifPresent(System.out::println);
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {//采集时间是10S  并行去执行任务

                e.printStackTrace();
            }

            synchronized (CONTROLS) {//工作完了我吧自己移除工作队列
                Optional.of("The worker [" + Thread.currentThread().getName() + "] END capture data.")
                        .ifPresent(System.out::println);
                CONTROLS.removeFirst();// 为什么remove
                // first?删掉的可能是自己也肯能是别人只要删掉就可以了 其实
                CONTROLS.notifyAll();
            }
        }, name);
    }

    private static class Control {
    }
}

对公共数据的操作要设置同步的保护的,这是真理。

——————————28———-控制并发————————-

自定义的锁解决synchronized的慢的问题:

代码chapter10

代码:

java并发编程实战wwj----------------------第一阶段--------------27-28-29-30

第一步:写一个接口

定义显示锁:


public interface Lock {

    class TimeOutException extends Exception {
        public TimeOutException(String message) {//报错信息
            super(message);
        }
    }

    void lock() throws InterruptedException;//加锁

    void lock(long mills) throws InterruptedException, TimeOutException;//没有获取到锁就退出来了

    void unlock();//释放锁

    Collection<Thread> getBlockedThread();//获得被阻塞的线程

    int getBlockedSize();//获得被阻塞的线程的个数

}

先看下最终的代码

package one.chapter10;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Optional;

public class BooleanLock implements Lock {

    //The initValue is true indicated the lock have be get.
    //The initValue is false indicated the lock is free (other thread can get this.)
    private boolean initValue;

    // 被阻塞的线程
    private Collection<Thread> blockedThreadCollection = new ArrayList<>();

    private Thread currentThread;//为什么第一这个变量,谁加的锁只能由谁去释放的。

    public BooleanLock() {
        this.initValue = false;
    }

    @Override
    public synchronized void lock() throws InterruptedException {
        while (initValue) {//true就是我不能抢到锁了就得等着
            if(!blockedThreadCollection.contains(Thread.currentThread())){
                blockedThreadCollection.add(Thread.currentThread());
            }
            this.wait();// 就在lock上wait
        }
        blockedThreadCollection.remove(Thread.currentThread());
        this.initValue = true;
        this.currentThread = Thread.currentThread();//设置lock是当前的线程虽然抢锁失败了
    }

    @Override
    public synchronized void unlock() {//这个synchronized锁的是BooleanLock的实例
        if (Thread.currentThread() == currentThread) {//是当前的线程才释放的
            this.initValue = false;
            Optional.of(Thread.currentThread().getName() + " release the lock monitor.")
                    .ifPresent(System.out::println);
            this.notifyAll();
        }
    }

       @Override
    public synchronized void lock(long mills) throws InterruptedException, TimeOutException {
        if (mills <= 0)
            lock();
        long hasRemaining = mills;//需要等的时间
        long endTime = System.currentTimeMillis() + mills;//到什么时间结束
        while (initValue) {//需要等待   醒了我就去抢锁,抢不到我就加时间  多次醒了请不到我就超时了 我直接抛出异常了
            if (hasRemaining <= 0)
                throw new TimeOutException("Time out");
            if(!blockedThreadCollection.contains(Thread.currentThread())){
                blockedThreadCollection.add(Thread.currentThread());
            }
            this.wait(mills);
            hasRemaining = endTime - System.currentTimeMillis();
        }
        blockedThreadCollection.remove(Thread.currentThread());
        this.initValue = true;
        this.currentThread = Thread.currentThread();
    }

    /**
     * 注意这个要考线程安全 其他的线程可以在其他的方法操作这个集合
     * @return
     */
    @Override
    public Collection<Thread> getBlockedThread() {
        return Collections.unmodifiableCollection(blockedThreadCollection);
    }

    @Override
    public int getBlockedSize() {
        return blockedThreadCollection.size();
    }
}

———-29——————————–

第一个一个bug:

java并发编程实战wwj----------------------第一阶段--------------27-28-29-30

t1加的锁只能t1去释放,其他的是不能去释放的。

  @Override
    public synchronized void lock() throws InterruptedException {
        while (initValue) {//true就是我不能抢到锁了就得等着
            if(!blockedThreadCollection.contains(Thread.currentThread())){
                blockedThreadCollection.add(Thread.currentThread());
            }
            this.wait();
        }

        blockedThreadCollection.remove(Thread.currentThread());
        this.initValue = true;
        this.currentThread = Thread.currentThread();//Thread.currentThread()这个是获取到锁的线程
    }

    @Override
    public synchronized void unlock() {//这个synchronized锁的是BooleanLock的实例
        if (Thread.currentThread() == currentThread) {//是当前的线程才释放的
            this.initValue = false;
            Optional.of(Thread.currentThread().getName() + " release the lock monitor.")
                    .ifPresent(System.out::println);
            this.notifyAll();
        }
    }

第二个问题:synchronized不能打断,导致等待时间长,这个是synchronized的工作机制。

package chapter10;


public class SynchronizedProblem {

    public static void main(String[] args) throws InterruptedException {

        new Thread() {
            @Override
            public void run() {
                SynchronizedProblem.run();
            }
        }.start();

        Thread.sleep(1000);

        Thread t2 = new Thread() {
            @Override
            public void run() {
//                /sdfsdfsd
                SynchronizedProblem.run();
                //sdfsdfsd
                System.out.println("继续做以下的事情t");
            }
        };
        t2.start();
        Thread.sleep(2000);
        t2.interrupt();
        System.out.println(t2.isInterrupted());
    }

    private synchronized static void run() {
        System.out.println(Thread.currentThread());
        while (true) {

        }
    }
}

t2可以打断但是不能中断进入java并发编程实战wwj----------------------第一阶段--------------27-28-29-30

t2是一直block住的。我们不能让t2释放回来。做线程的其他的事情。

java并发编程实战wwj----------------------第一阶段--------------27-28-29-30我们要解决这个问题。

    @Override
    public synchronized void lock(long mills) throws InterruptedException, TimeOutException {
        if (mills <= 0)
            lock();
        long hasRemaining = mills;//需要等的时间
        long endTime = System.currentTimeMillis() + mills;//到什么时间结束
        while (initValue) {//需要等待   醒了我就去抢锁,抢不到我就加时间  多次醒了请不到我就超时了 我直接抛出异常了
            if (hasRemaining <= 0)
                throw new TimeOutException("Time out");
            if(!blockedThreadCollection.contains(Thread.currentThread())){
                blockedThreadCollection.add(Thread.currentThread());
            }
            this.wait(mills);
            hasRemaining = endTime - System.currentTimeMillis();
        }
        blockedThreadCollection.remove(Thread.currentThread());
        this.initValue = true;
        this.currentThread = Thread.currentThread();
    }

——————————-30——————————-

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/188765.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • Java常见Exception物种

    Java常见Exception物种

  • 一体化能源行业大数据平台建设,让能源更“聪明”

    一体化能源行业大数据平台建设,让能源更“聪明”现在能源行业,不论是政府政策还是群众呼应,都要求建设智能智慧能源行业,今天我们从为什么,怎么做来为大家讲解如何建设能源行业大数据。能源大数据理念是将电力、石油、燃气等能源领域数据进行综合采集、处理、分析与应用的相关技术与思想。能源大数据不仅是大数据技术在能源领域的深入应用,也是能源生产、消费及相关技术革命与大数据理念的深度融合,将加速推进能源产业发展及商业模式创新。随着信息化的深入和两化的深度融合,大数据在石油石化行业应用的前景将越来越广阔。大数据与能源行业的结合目前主要体现在三个行业。(1)石

  • javascript页面刷新的几种方法[通俗易懂]

    javascript页面刷新的几种方法[通俗易懂]javascript页面刷新的几种方法javascriptrefreshpage几种页面刷新的方法window.location.reload(),window.history.go(0)和document.execCommand(”Refresh”),这三个方法是最快速的。其他的都有明显的浏览器滚动条的出现。Javascript刷新页面的几种方法: 1

  • js的数据类型有哪些?[通俗易懂]

    js的数据类型有哪些?[通俗易懂]数据类型一、数据类型:基本数据类型(值类型):字符串(String)、数字(Number)、布尔(Boolean)、对空(Null)、未定义(Undefined)。引用数据类型(对象类型):对象(Object)、数组(Array)、函数(Function)。特殊的对象:正则(RegExp)和日期(Date)。特殊类型:underfined未定义、Null空对象、Infinate无穷、NAN非数字基本数据类型的值直接在栈内存中存储,值与值之间独立存在,修改一个变量不会影响.

  • Java实习入职华为,半年后我跑路了

    Java实习入职华为,半年后我跑路了0前言全是干货的技术殿堂文章收录在我的GitHub仓库,欢迎Star/fork:Java-Interview-Tutorialhttps://github.com/Wasabi1234/Java-Interview-Tutorial1何来?我,一个双非本科渣渣,有幸在19届的秋招中得到前东家华为(以下简称hw)的赏识,当时秋招签订就业协议,当时18年10月签订三方后Hr通知说是入了某java部门,之后一系列组织架构调整原因等等让人无法理解的骚操作,最终在毕业前夕的五

  • ROS学习(开篇)Ubuntu16.04安装ROS Kinetic详细教程

    ROS学习(开篇)Ubuntu16.04安装ROS Kinetic详细教程之前关于ROS学习的博客,都是在win10虚拟机环境下运行的ubuntu18.04系统,对应的ros版本为melodic。由于电脑性能不好,运行导航仿真感觉卡顿,所以我把家里的台式机搞成了ubuntu16.04和win10双系统。ubuntu16.04系统的安装网上很多资料,本篇只是记录下ros的安装步骤,仅供参考。本篇文章只解决我遇到的错误,若不能解决你的错误,请自行百度,哈哈,网上的资料还是很多的。

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号