Java Web随笔

梦里梦外; 2021-09-29 07:42 264阅读 0赞

# IO #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70]

# 异或 #

换成二进制以后 异或(^)操作运算规则为相同的为0，不同的为1

*  交换
 *  找出不同的字符

/**
     * @Description: java类作用描述
     * @Author: Bsea
     * @CreateDate: 2019/12/9$ 20:05$
     */
    public class Question1 {
    
        public static void main(String[] args) {
    
    //        System.out.println( findTheDifference("abcd","abfcd"));
    
            exchange(66,88);
        }
    
        public static char findTheDifference(String s, String t) {
             char[] chars=s.toCharArray();
             char[] chars1=t.toCharArray();
             int rs=0;
             for(char c1:chars){
               rs=rs^ c1;
             }
    
            int rs1=0;
            for(char c1:chars1){
                rs1=rs1^ c1;
            }
            System.out.println(rs1^rs);
            int d=rs1^rs;
            char e=(char)d;
             return  e;
        }
    
        /**
         * 2、异或操作进行数字交换
         * 我们现在有两个数a，b，我们可以通过异或操作对他们俩的数字进行交换
         *
         * a = a ^ b
         *
         * b = b ^ a
         *
         * a = a ^ b
         */
        public static  void exchange(int a, int b){
            //交换
    //        int temp=a;
    //        a=b;
    //        b=temp;
    
            a=a^b;
            b=a^b;
            a=a^b;
    
    
            System.out.println("a="+a);
            System.out.println("b="+b);
    
        }
    }

# 线程 #

## 如何停止一个正在运行的线程？ ##

一共有三种方式， 最好的方式是使用退出标志。  
1、使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。  
2、使用stop方法强行终止，但是不推荐这个方法，因为stop和suspend及resume一样都是过期作废的方法。  
3、使用interrupt方法中断线程。

## sleep()和 wait()有什么区别? ##

1，sleep不会释放对象锁，wait会释放对象锁。  
2， sleep是Thread类的方法，wait是Object的方法

## 当一个线程进入某个对象的一个synchronized的实例方法后，其它线程是否可进入此对象的其它方法？ ##

如果其他方法前加了synchronized关键字，就不能，如果没加synchronized，则能够进去。

如果这个方法内部调用了wait(),则可以进入其他加synchronized的方法。

如果其他方法加了synchronized关键字，并且没有调用wai方法，则不能。

## Java 线程安全和不安全 ##

线程安全就是要让程序运行出我们想要的结果  
线程安全就是说多线程访问同一代码，不会产生不确定的结果。  
servlet线程不安全。

假设A和B同时去不同ATM上取同一张卡的1000块钱，如果是线程不安全，那么A和B可以同时取到1000块钱（两人赚大发啦），而如果线程安全呢，就只有一个人能取出来1000块钱

https://blog.csdn.net/h356363/article/details/90723274

## 读写锁 ##

使用synchronized无法实现排除读与读的互斥，这时候就需要 ReentrantReadWriteLock来实现读写锁。

参考：  
https://blog.csdn.net/amanicspater/article/details/76209121

访问测试类：

public class ReadWriteLockTest \{  
public static void main(String\[\] args) \{  
Datetest datetest = new Datetest();  
for (int i = 0; i < 5; i++) \{  
new Thread(new Runnable() \{  
@Override  
public void run() \{  
datetest.set(new Random().nextInt(30));  
\}  
\},“写线程：”+i+"->").start();  
\}

for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    datetest.get();
                }
            },"读线程"+i+"->").start();
        }
    }

不使用同步：

public class Datetest \{  
private int data;

public /*synchronized*/ void set(int s){
        System.out.println(Thread.currentThread().getName()+"----准备写入数据："+s);
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.data = s;
        System.out.println(Thread.currentThread().getName()+"----成功写入数据："+this.data);
    }
    
    public /*synchronized*/ void get(){
        System.out.println(Thread.currentThread().getName()+"----准备读取数据");
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.data);
        System.out.println(Thread.currentThread().getName()+"----成功读取数据");
    }

\}  
结果：  
写线程：0->----准备写入数据：6  
写线程：1->----准备写入数据：18  
写线程：2->----准备写入数据：16  
写线程：3->----准备写入数据：2  
写线程：4->----准备写入数据：23  
读线程0->----准备读取数据  
读线程1->----准备读取数据  
读线程2->----准备读取数据  
读线程3->----准备读取数据  
读线程4->----准备读取数据  
写线程：2->----成功写入数据：16  
写线程：0->----成功写入数据：16  
写线程：4->----成功写入数据：23  
写线程：1->----成功写入数据：16  
写线程：3->----成功写入数据：2  
23  
23  
读线程2->----成功读取数据  
23  
读线程1->----成功读取数据  
读线程0->----成功读取数据  
23  
23  
读线程3->----成功读取数据  
读线程4->----成功读取数据  
可以看到结果很乱。

使用synchronized：

public class Datetest \{  
private int data;

\}  
结果：  
写线程：0->----准备写入数据：2  
写线程：0->----成功写入数据：2  
读线程4->----准备读取数据  
2  
读线程4->----成功读取数据  
读线程3->----准备读取数据  
2  
读线程3->----成功读取数据  
读线程2->----准备读取数据  
2  
读线程2->----成功读取数据  
读线程1->----准备读取数据  
2  
读线程1->----成功读取数据  
读线程0->----准备读取数据  
2  
读线程0->----成功读取数据  
写线程：4->----准备写入数据：17  
写线程：4->----成功写入数据：17  
写线程：3->----准备写入数据：7  
写线程：3->----成功写入数据：7  
写线程：2->----准备写入数据：26  
写线程：2->----成功写入数据：26  
写线程：1->----准备写入数据：7  
写线程：1->----成功写入数据：7  
可以看到读与读互斥

使用Lock：

public class Datetest \{  
private int data;  
private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();  
public void set(int s)\{  
readWriteLock.writeLock().lock();  
try\{  
System.out.println(Thread.currentThread().getName()+"----准备写入数据："+s);  
try \{  
Thread.sleep(20);  
\} catch (InterruptedException e) \{  
e.printStackTrace();  
\}  
this.data = s;  
System.out.println(Thread.currentThread().getName()+"----成功写入数据："+this.data);  
\}finally \{  
readWriteLock.writeLock().unlock();  
\}

}
    
    public void get(){
        readWriteLock.readLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"----准备读取数据");
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.data);
            System.out.println(Thread.currentThread().getName()+"----成功读取数据");
        }finally {
            readWriteLock.readLock().unlock();
        }
    
    }

\}  
结果：  
写线程：0->----准备写入数据：1  
写线程：0->----成功写入数据：1  
写线程：1->----准备写入数据：24  
写线程：1->----成功写入数据：24  
写线程：2->----准备写入数据：14  
写线程：2->----成功写入数据：14  
写线程：3->----准备写入数据：23  
写线程：3->----成功写入数据：23  
写线程：4->----准备写入数据：0  
写线程：4->----成功写入数据：0  
读线程0->----准备读取数据  
读线程1->----准备读取数据  
读线程2->----准备读取数据  
读线程3->----准备读取数据  
读线程4->----准备读取数据  
0  
0  
0  
读线程2->----成功读取数据  
0  
读线程1->----成功读取数据  
读线程3->----成功读取数据  
读线程0->----成功读取数据  
0  
读线程4->----成功读取数据  
写与写互斥了但是读与读不互斥。

package com.zz.thread.readwrite;/**
     * @Description: 描述
     * @Author: Bsea
     * @CreateDate: 2019/12/4
     */
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    /**
     * @Description: java类作用描述
     * @Author: Bsea
     * @CreateDate: 2019/12/4$ 21:13$
     */
    public class LockDemo {
        // new一个锁对象，注意此处必须声明成类对象，保持只有一把锁,ReentrantLock是Lock的唯一实现类
    //    Lock lock = new ReentrantLock();
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        public void readFile(String fileMessage){
    //        lock.lock();// 上锁
            lock.readLock().lock();// 上读锁
            try {
                System.out.println(Thread.currentThread().getName()+"得到了锁，正在读取文件……");
                for (int i = 0; i< fileMessage.length(); i++){
                    System.out.print(fileMessage.charAt(i));
                }
                System.out.println();
                System.out.println("文件读取完毕！");
            } finally {
                System.out.println(Thread.currentThread().getName()+"释放了锁！");
    //            lock.unlock();
                lock.readLock().unlock();// 放读锁
            }
        }
    
        public static void main(String[] args) {
            LockDemo demo = new LockDemo();
            String fileName = "C:\\tmp\\demo.txt";
            // 创建若干个线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    demo.readFile(fileName);
                }
            }).start();
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    demo.readFile(fileName);
                }
            }).start();
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    demo.readFile(fileName);
                }
            }).start();
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    demo.readFile(fileName);
                }
            }).start();
        }
    
    }

## 生产者消费者模型 ##

生产者

package com.zz.thread.demo2;/**
     * @Description: 描述
     * @Author: Bsea
     * @CreateDate: 2019/12/6
     */
    import java.util.LinkedList;
    import java.util.Random;
    /**
     * @Description: java类作用描述
     * @Author: Bsea
     * @CreateDate: 2019/12/6$ 21:39$
     */
    public class Producer implements Runnable
    {
    
        private final LinkedList<Integer> list;
    
        /**
         * 缓冲区大小
         */
        private final int maxSize;
    
        public Producer(LinkedList list, int size)
        {
            this.list = list;
            maxSize =size;
        }
    
        @Override
        public void run()
        {
            try
            {
                while(true)
                {
                    //模拟耗时1s
                    Thread.sleep(1000);
                    synchronized (list)
                    {
                        if(list.size()==maxSize)
                        {
                            System.out.println("缓冲区已满，正在等待消费者消费..." + System.currentTimeMillis());
                            list.wait();
                        }
                        else
                        {
                            list.add(produce());
                            list.notifyAll();
                        }
                    }
    
                }
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    
        private int produce()
        {
            int n = new Random().nextInt(10000);
            System.out.println("Thread: " + Thread.currentThread().getName() + " produce: " + n);
            return n;
        }
    }

消费者

package com.zz.thread.demo2;/**
     * @Description: 描述
     * @Author: Bsea
     * @CreateDate: 2019/12/6
     */
    import java.util.Date;
    import java.util.LinkedList;
    /**
     * @Description: java类作用描述
     * @Author: Bsea
     * @CreateDate: 2019/12/6$ 21:40$
     */
    public class Consumer implements Runnable
    {
        private final LinkedList<Integer> list;
    
        public Consumer(LinkedList list)
        {
            this.list = list;
        }
    
        @Override
        public  void run()
        {
            while (true)
            {
                try
                {
                    synchronized(list)
                    {
                        //模拟耗时
                        Thread.sleep(1000);
                        if(list.isEmpty())
                        {
                            System.out.println("缓冲区已空，正在等待生产者生产..." + System.currentTimeMillis() + Thread.currentThread().getName());
                            list.wait();
                        }
                        else
                        {
                            consume(list.poll());
                            list.notifyAll();
                        }
                    }
    
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
    
        }
    
        private void consume(Integer n)
        {
            System.out.println("Thread:" + Thread.currentThread().getName() + " consume: " + n);
        }
    }

测试

package com.zz.thread.demo2;/**
     * @Description: 描述
     * @Author: Bsea
     * @CreateDate: 2019/12/6
     */
    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;
    /**
     * @Description: java类作用描述
     * @Author: Bsea
     * @CreateDate: 2019/12/6$ 21:46$
     */
    public class Test {
        public static void main(String[] args)
        {
            LinkedList<Integer> list = new LinkedList<>();
            Producer p = new Producer(list, 10);
            Consumer c1 = new Consumer(list);
            Consumer c2 = new Consumer(list);
    
            Thread producer = new Thread(p);
            producer.setName("生产者线程");
            Thread consumer1 = new Thread(c1);
            consumer1.setName("消费者1");
            Thread consumer2 = new Thread(c2);
            consumer2.setName("消费者2");
    
            producer.start();
            consumer1.start();
            consumer2.start();
    
        }
    }

# 题目 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70 1]

# 分析 #

2.1

CREATE TABLE `dydj` (
      `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
      `minval` int(11) DEFAULT NULL COMMENT '>=最小值',
      `maxval` int(11) DEFAULT NULL COMMENT '<最大值',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8

3.1

CREATE TABLE `ydtype` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `val` varchar(20) DEFAULT NULL COMMENT '用电类型显示的值，比如一般工业用电',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8

CREATE TABLE `dj` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `ydtype_id` int(11) DEFAULT NULL COMMENT '用电类型表的id',
      `dydj_id` int(11) DEFAULT NULL COMMENT '用电类型id',
      `jf` decimal(10,0) DEFAULT NULL COMMENT '尖峰电价',
      `gf` decimal(10,0) DEFAULT NULL COMMENT '高峰电价',
      `pd` decimal(10,0) DEFAULT NULL COMMENT '平段电价',
      `dj` decimal(10,0) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8

3.2 思路

设备开机和关机，分别创建一个API 接口。

开机的时候，开机API 接口被执行，请求的request

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70]: /images/20210726/378dac6075454840b4d642ae56bc4429.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70 1]: /images/20210726/ae0d173cfb834394a7fc45080b74c3c5.png