多线程练习

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量545 收藏 8
点赞数 10
文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79947226/article/details/136125110
版权

做以下练习的基本步骤：

  1. 定义共享变量（若要创建多个对象使用静态）；
  2. 写循环（while）
    1. 有时候不写while，比如说抢红包每条线程只能抢一次，就不用while循环
  3. 同步代码块
  4. 判断（已经到末尾）
  5. 再判断（没有到末尾）

重点1：要知道共享变量是定义在javaBean内，还是定义在main方法中（创建对象时传递过来）
重点2:要清楚while循环的结束条件是什么，

1.

image.png
SelTickets类：

public class SellTickets extends Thread{

    private static int tickets=1;


    @Override
    public void run() {
        //1循环
        while(true){
            //2同步代码块确保线程安全
            synchronized (SellTickets.class){
                //3判断
                if (tickets==1000){
                    break;
                }else {
                    //让当前线程睡30毫秒
                    try {
                        Thread.sleep(30);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }

                    System.out.println(Thread.currentThread().getName()+":正在卖第"+tickets+"张票");
                    tickets++;
                }
            }
        }
    }
}

main：

public class Test {
    public static void main(String[] args) {
        //创建两个线程
        SellTickets s1=new SellTickets();
        SellTickets s2=new SellTickets();
        //设名字
        s1.setName("窗口一");
        s2.setName("窗口二");
        //开始
        s1.start();
        s2.start();

    }
}

2.

image.png

public class MyRun implements Runnable{
    //第二种方式实现多线程，测试类中MyRunable只创建一次，所以不需要加static
    private  int gift=100;


    @Override
    public void run() {
        //1.循环
        while(true){
            //2.同步代码块确保线程安全
            synchronized (MyRun.class){
                //让当线程小睡一会
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                //3.判断
                if (gift<10){
                    break;
                }else {
                    gift--;
                    System.out.println(Thread.currentThread().getName()+"正在送，还剩："+gift+"份");
                }
            }
        }
    }
}

main

public class Test {
    public static void main(String[] args) {

        //线程任务
        MyRun m=new MyRun();
        //创建线程
        Thread t1=new Thread(m);
        Thread t2=new Thread(m);
        //设置名字
        t1.setName("小王");
        t2.setName("小李");
        //开始
        t1.start();
        t2.start();
    }
}

image.png

3

image.png
使用第三种方法

public class MyRunable implements Runnable {
//第二种方式实现多线程，测试类中MyRunable只创建一次，所以不需要加static
    private int number = 1;

    @Override
    public void run() {
        //循环
        while (true) {

            //同步代码块确保线程安全
            synchronized (MyCall.class) {
                //判断
                if (number <= 100) {
                    if (number % 2 == 1) {
                        System.out.println(Thread.currentThread().getName() + "打印数字" + number);
                    }
                    number++;
                } else {
                    break;
                }
            }
        }
    }
}

main

public class Test {
    public static void main(String[] args) {

        MyRunable mc=new MyRunable();

        //创建线程传入mc参数
        Thread t1=new Thread(mc);
        Thread t2=new Thread(mc);

        t1.setName("线程一");
        t2.setName("线程二");

        t1.start();
        t2.start();
    }
}

4.

.image.png
改进前：

public class Grab extends Thread {
    //使用第一种方法，可能创建多个线程使用静态修饰
    private static double money = 100;
    //红包个数
    static int count = 3;
    //最小的中奖金额
    static final double MIN = 0.01;

    @Override
    public void run() {
         //循环舍弃：抢红包一人只能抢一次
        //同步代码块保证线程安全
        synchronized (Grab.class) {
            if (count == 0) {
                //如果没红包了就说明没抢到
                System.out.println(getName() + "没抢到红包");
            } else {
                //还有红包
                //定义一个变量表示中奖的金额
                double prize = 0;
                if (count == 1) {
                    //表示是最后一个红包，抽取剩下的钱即可
                    prize = money;
                } else {
                    //第一个和第二个红包
                    Random r = new Random();
                    //要知道第一个红包最多抽到99.98元 （因为100要分成3个包）
                    //100-（count-1）*min,在这个范围内抽
                    //若第一个红包最多抽到99.98元，则第二个红包最多抽到0.01元 （因为100要分成3个包）
                    //100-99.98-（count-1）*min,在这个范围内抽
                    prize = r.nextDouble(money - (count - 1) * MIN);
                    //又因为抽红包有可能抽到比0.01还小的数，所以强制改为0.01
                    if (prize < MIN) {
                        prize = MIN;
                    }
                }
                System.out.println(getName() + "抢到了" + prize);
                //更改红包数
                count--;
                //更改money
                money -= prize;
            }
        }
    }
}

main

public class Test {
    public static void main(String[] args) {

        //创建5个线程
        Grab g1=new Grab();
        Grab g2=new Grab();
        Grab g3=new Grab();
        Grab g4=new Grab();
        Grab g5=new Grab();

        //给线程设置名字
        g1.setName("小A");
        g2.setName("小B");
        g3.setName("小C");
        g4.setName("小D");
        g5.setName("小E");

        //启动线程
        g1.start();
        g2.start();
        g3.start();
        g4.start();
        g5.start();
    }
}

image.png
发现有问题：小数位并没有保留两位，不贴近现实

改进后：

public class Grab2 extends Thread {
    //使用第一种方法，可能创建多个线程使用静态修饰
    private static BigDecimal money = BigDecimal.valueOf(100);
    //红包个数
    static int count = 3;
    //最小的中奖金额
    static final BigDecimal MIN = BigDecimal.valueOf(0.01);

    @Override
    public void run() {
        //循环舍弃：抢红包一人只能抢一次
        //同步代码块确保线程安全
        synchronized (Grab2.class) {
            if (count == 0) {
                //如果没红包了就说明没抢到
                System.out.println(getName() + "没抢到红包");
            } else {
                //还有红包
                //定义一个变量表示中奖的金额
                BigDecimal prize;
                if (count == 1) {
                    //表示是最后一个红包，抽取剩下的钱即可
                    prize = money;
                } else {
                    //第一个和第二个红包
                    Random r = new Random();
                    //要知道第一个红包最多抽到99.98元 （因为100要分成3个包）
                    //100-（count-1）*min,在这个范围内抽
                    //若第一个红包最多抽到99.98元，则第二个红包最多抽到0.01元 （因为100要分成3个包）
                    //100-99.98-（count-1）*min,在这个范围内抽
                    double bounds = money.subtract(BigDecimal.valueOf(count - 1).multiply(MIN)).doubleValue();
                    prize = BigDecimal.valueOf(r.nextDouble(bounds));
                    //又因为抽红包有可能抽到比0.01还小的数，所以
                }
                //四舍五入
                prize = prize.setScale(2, RoundingMode.HALF_UP);
                System.out.println(getName() + "抢到了" + prize);
                //更改红包数
                count--;
                //更改money
                money=money.subtract(prize);
            }
        }
    }
}

main

public class Test {
    public static void main(String[] args) {


        Grab2 g1=new Grab2();
        Grab2 g2=new Grab2();
        Grab2 g3=new Grab2();
        Grab2 g4=new Grab2();
        Grab2 g5=new Grab2();

        //给线程设置名字
        g1.setName("小A");
        g2.setName("小B");
        g3.setName("小C");
        g4.setName("小D");
        g5.setName("小E");

        //启动线程
        g1.start();
        g2.start();
        g3.start();
        g4.start();
        g5.start();


    }
}

image.png

5.

image.png
这里的难点是这个奖池应该定义在哪, javabean的成员位置还是？

在Java中，如果你在main方法中创建了两个JavaBean对象，并且在构造这两个对象时都传递了同一个List集合的引用，那么这两个JavaBean对象将操作同一个集合。这意味着对任何一个对象通过该集合进行的增删改查操作，都会影响到另一个对象通过该集合看到的数据。
具体见：**基本数据类型和引用数据类型的特性

public class Prize implements Runnable {
        
    ArrayList<Integer> list;

    //构造，从创建对象时传递一个集合过来
    public Prize(ArrayList<Integer> list) {
        this.list = list;
    }


    @Override
    public void run() {
        //循环
        while (true) {
            //同步代码块，确保线程安全
            synchronized (Prize.class) {
                if (list.isEmpty()) {
                    break;
                }
                //随机获取集合元素----抽奖
                Collections.shuffle(list);
                Integer num = list.remove(0);
                System.out.println(Thread.currentThread().getName() + "又产生了一个" + num + "元的大奖");
            }
            
            //让当前线程睡一会，给别的线程机会
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }


        }
    }
}

main

public class Test {
    public static void main(String[] args) {
        //创建奖池
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);

        //传入参数
        Prize t = new Prize(list);
        //创建线程并传入t
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);

        //设置名字
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");

        //启动线程
        t1.start();
        t2.start();
    }
}

image.png

6.

image.png

public class Prize implements Runnable {

    ArrayList<Integer> list;

    //构造，从main方法传递一个集合过来
    public Prize(ArrayList<Integer> list) {
        this.list = list;
    }

    //用两个变量记录 两个抽奖箱产生中奖次数
    int count1 = 0;
    int count2 = 0;
    //用两个集合存储奖项
    ArrayList<Integer> list1 = new ArrayList<>();
    ArrayList<Integer> list2 = new ArrayList<>();
    

    @Override
    public void run() {
        //循环
        while (true) {
            //同步代码块，确保线程安全
            synchronized (Prize.class) {
                
                if (list.isEmpty()) {
                    //当奖箱全部获取完了就开始打印
                     if ("抽奖箱1".equals(Thread.currentThread().getName())) {
                         //求最大值
                        Integer max = Collections.max(list1);
                        System.out.println("抽奖箱1" + list1+":"+count1+"个奖项，最大值是"+max);
                    } else {
                         //求最大值
                        Integer max = Collections.max(list2);
                        System.out.println("抽奖箱2" + list2+":"+count2+"个奖项，最大值是"+max);
                    }
                    break;
                    
                } else {
                    //list大小不是0，继续抽奖
                    //随机获取元素
                    Collections.shuffle(list);
                    Integer prize = list.remove(0);
                    
                    if ("抽奖箱1".equals(Thread.currentThread().getName())) {
                        //添加到list1
                        list1.add(prize);
                        //个数++
                        count1++;
                    } else {
                        //添加到list2
                        list2.add(prize);
                        //个数++
                        count2++;
                    }
                }
                
            }
            //让当前线程睡一会，给别的线程机会
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            
        }
    
    }
}

main

public class Test {
    public static void main(String[] args) {
        //创建奖池
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);

       
        Prize t = new Prize(list);
         //创建线程
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);

        //设置名字
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");

        //启动线程
        t1.start();
        t2.start();

    }
}

image.png

这种方法的弊端：当有非常多的抽奖箱时（线程），不可能一个个创建集合来存储中奖项
改进：在run方法内定义一个box集合，创建多个线程时会调用run方法来创建线程对应的集合

public class Prize implements Runnable {

    ArrayList<Integer> list;

    //构造，从main方法传递一个集合过来
    public Prize(ArrayList<Integer> list) {
        this.list = list;
    }

    //用两个变量记录 两个抽奖箱产生中奖次数
    int count1 = 0;
    int count2 = 0;
    

    @Override
    public void run() {
        //在run方法内创建一个集合，创建多少个线程就会创建多少个相应的集合
        ArrayList<Integer>box=new ArrayList<>();
        //循环
        while (true) {
            //同步代码块，确保线程安全
            synchronized (Prize.class) {
                if (list.isEmpty()) {
                    //当奖箱全部获取完了就开始打印
                    if ("抽奖箱1".equals(Thread.currentThread().getName())) {
                        int max = Collections.max(box);
                        System.out.println("抽奖箱1" + box + ":" + count1 + "个奖项，最大值是" + max);
                    } else {
                        int max = Collections.max(box);
                        System.out.println("抽奖箱2" + box + ":" + count2 + "个奖项，最大值是" + max);
                    }
                    break;

                } else {
                        //继续抽奖（打乱获取第一个）
                    Collections.shuffle(list);
                    Integer prize = list.remove(0);

                    if ("抽奖箱1".equals(Thread.currentThread().getName())) {
                        //放入box
                        box.add(prize);
                        //奖项数
                        count1++;
                    } else {
                        //放入box
                        box.add(prize);
                        //奖项数
                        count2++;
                    }

                }
            }
            //让当前线程睡一会，给别的线程机会
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

image.png

为什么可以这样改进？
内存图：
image.png

7.

需求：最后一句
image.png
思路：
首先代码一定是写在while循环之后的，因为抽奖已经结束
首先要知道抽奖箱1和2的奖项的最大值，我们可以使用第三种方式创建多线程，因为call方法有返回值

public class Prize implements Callable<Integer> {
    //定义一个变量
    ArrayList<Integer> list;

    //构造，从main方法传递一个集合过来
    public Prize(ArrayList<Integer> list) {
        this.list = list;
    }

    //用两个变量记录 两个抽奖箱产生中奖次数
    int count1 = 0;
    int count2 = 0;


    @Override
    public Integer call() throws Exception {
        在run方法内创建一个集合，创建多少个线程就会创建多少个相应的集合
        //线程1 //线程2
        ArrayList<Integer> box = new ArrayList<>();
        //循环
        while (true) {
            //同步代码块，确保线程安全
            synchronized (Prize.class) {
                if (list.isEmpty()) {
                    //当奖箱全部获取完了就开始打印
                    if ("抽奖箱1".equals(Thread.currentThread().getName())) {
                        int max = Collections.max(box);
                        System.out.println("抽奖箱1" + box + ":" + count1 + "个奖项，最大值是" + max);
                    } else {
                        int max = Collections.max(box);
                        System.out.println("抽奖箱2" + box + ":" + count2 + "个奖项，最大值是" + max);
                    }
                    break;

                } else {
                    //继续抽奖
                    Collections.shuffle(list);
                    Integer prize = list.remove(0);

                    if ("抽奖箱1".equals(Thread.currentThread().getName())) {
                        box.add(prize);
                        count1++;
                    } else {
                        box.add(prize);
                        count2++;
                    }
                }
            }
            //让当前线程睡一会，给别的线程机会
            Thread.sleep(10);
        }
        ----while循环外
        //抽奖结束，循环结束，返回box中的最大奖项
        //要知道线程一或二的box中的奖项有可能没有，要特别考虑
        if (box.isEmpty()){
            return null;
        }else {
            return Collections.max(box);
        }
        
    }
}

main、

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建奖池
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);

        //创建多线程要运行的参数对象
        Prize t = new Prize(list);


        //*这里创建俩个FutureTask对象，因为你不知道的是javabean返回的最大值是线程1还是2的，所以创建两个分别管理线程  
        //线程一的任务管理器，接收返回值
        FutureTask<Integer> ft1=new FutureTask<>(t);
        //线程二的任务管理器，接受返回值
        FutureTask<Integer> ft2=new FutureTask<>(t);

        
        //创建线程1、2
        Thread t1=new Thread(ft1);
        Thread t2=new Thread(ft2);

        //设置名字
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");

        //启动线程
        t1.start();
        t2.start();

        //调用get方法获取返回值
        //线程1的最大值
        Integer i1 = ft1.get();
        //线程2的最大值
        Integer i2 = ft2.get();
        //打印
        System.out.println(i1+" "+i2);

        if (i1>i2){
            System.out.println("在此次抽奖过程中，抽奖箱1产生了最大奖项，该奖项金额为800");
        }else {
            System.out.println("在此次抽奖过程中，抽奖箱2产生了最大奖项，该奖项金额为800");
        }


    }
}

image.png

成果、
关注
java多线程练习_java基础之多线程提升训练练习题
weixin_35500243的博客
02-12 473
第四节 多线程更多练习题练习题1：三个线程交替打印数字启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5 然后是线程2打印6,7,8,9,10 然后是线程3打印11,12,13,14,15.接着再由线程1打印16,17,18,19,20....依次类推, 直到打印到60。提示：定义一个同步方法，在方法中使用循环的方式输出连续的5个数字，方法执行前，可以通过标记的方式判断是否是当前线程应该...
多线程：当你提交任务时，线程队列已经满了，这时会发生什么？
热门推荐
五山口老法师
01-14 1万+
  首先我调用Executors创建的线程池出来的对象是ThreadPoolExecutor,ScheduledThreadPoolExecutor,DelegatedExecutorService这三个类中的一个! 而ScheduledThreadPoolExecutor是ThreadPoolExecutor的子类, DelegatedExecutorService是对ExecutorServ...
多线程综合练习
Janna_woo的博客
04-01 372
多线程综合练习
实验题目：多线程
西_北
03-31 689
实验题目：多线程 目的与要求：熟悉多线程的创建以及线程的同步。 内容： 编写一个应用程序，除了主线程外，还有两个子线程。两个子线程对同一个数据操作，其中一个线程负责对该数据做递增操作，一个线程负责对该线程做递减操作。当这个数据小于0的话，递减操作等待，当这个数据大于100的话，递增操作等待。 package angry; class SyncStack {
多线程（一）
weixin_45569897的博客
08-24 183
一、线程线程代码完成继承Thread的方式创建分线程，并遍历100以内的自然数代码完成实现Runnable接口的方法创建分线程，并遍历100以内的自然数对比两种创建方式总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchar
关于多线程并发
大雪纷斐的博客
10-24 236
什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支持，它也是一个很好的卖点。欲了解更多详细信息请点击这里。 线程和进程有什么区别？ 线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内..
Java多线程练习
u010836872的博客
04-26 606
Java多线程练习 在main方法中使用三个线程，向一个List集合中按顺序添加1到10共十个数字，添加完成后在控制台打印这个List的值（应该是[1,2,3,4,5,6,7,8,9,10]），然后结束程序执行。 import java.util.ArrayList; import java.util.List; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.u
Java 多线程练习
qq_57570052的博客
07-28 2531
1.定时器操作（实现电脑定时关机）。2.每个月的月末(02:00:00)执行一次代码3.模拟售票模拟了多个线程同时售票的场景，保证了并发环境下的票的售卖过程的正确性和一致性。4.用15个线程实现，求123456789之间放+-和为100的表达式（11结果），如果一个线程求出结果， 立即告诉其它停止。
java多线程练习题
xwt1130_的博客
11-13 1135
java多线程练习题
多线程demo/java多线程练习
05-17
本项目"多线程demo/java多线程练习"旨在通过实际操作来深入理解和掌握多线程技术，同时模拟数据库操作，这在现代应用程序开发中至关重要。 1. **线程基础** - **创建线程**：Java提供了两种创建线程的方式，分别是...
易语言-鱼刺多线程练习
06-25
"鱼刺多线程练习"是一个易语言的实例项目，旨在帮助学习者掌握如何在易语言中实现多线程编程。 多线程是现代计算机程序设计中的一个重要概念，它允许一个应用程序同时执行多个不同的任务或子任务，从而提高程序的...
java多线程之赛马程序实验8多线程练习下载进度
05-19
本实验"java多线程之赛马程序实验8多线程练习下载进度"聚焦于如何利用多线程来模拟实际场景中的下载进度显示。在这一过程中，我们将探讨Thread类的`run`和`start`方法，以及如何通过进度条来可视化表示下载过程。 ...
Java多线程练习源代码
01-11
本资源“Java多线程练习源代码”提供了一系列的示例，旨在帮助开发者深入理解和熟练掌握Java多线程的运用。 1. **线程的概念与创建** 线程是程序执行的最小单元，一个进程可以有多个线程同时执行任务。在Java中，...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 129
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 809
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 864
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 249
默认对常规Session的理解和使用，如何使用Set-Cookie。
函数式接口与回调函数实践
m0_37635053的博客
10-29 407
函数式接口与回调函数
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

成果、

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值