Java学习 DAY20 Properties、断言、线程

Properties

可以进行持久化的映射类（父类时Hashtable）
键和值都是字符串类型
properties文件都是默认是以GBK来进行编码，但是如果出现中文以u16进行编码
当作配置文件来使用

package cn.tedu.properties;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class PropertiesDemo1 {
    public static void main(String[] args) throws IOException {
        //创建映射类对象
        Properties p=new Properties();
        //添加元素
        p.setProperty("name","tom");
        p.setProperty("age","10");
        p.setProperty("gender","male");

        //进行持久化---文件类型要是.properties
        p.store(new FileOutputStream
                ("person.properties"),"per");
    }
}

package cn.tedu.properties;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class PropertiesDemo2 {
    public static void main(String[] args) throws IOException {
        //创建映射类对象
        Properties p=new Properties();

        //加载Properties文件内容
        p.load(new FileInputStream("person.properties"));

        //获取映射里内容
        //根据键来获取值
        System.out.println(p.getProperty("name"));
        //展示映射数据
        p.list(System.out);
    }
}

单元测试

步骤
1.导入测试库
2.给出测试方法（三无方法—没有返回值、没有参数、没有static）
3.在测试方法里调用待测试的方法

package cn.tedu.junit;

import org.junit.Test;

public class JunitDemo {

    public static void main(String[] args) {
        System.out.println(3);
    }


    //导入测试库
    //测试方法---无参方法、没有返回值、没有Static修饰的方法（三无方法）
    @Test
    public void m(){
        System.out.println(1);
        //调用测试的方法
        System.out.println(n(10));;
    }

    public int n(int i){
        return i+2;
    }
}

断言

对结果进行预测，如果预测成功则运行通过如果预测失败则会报错
使用断言之前必须开启断言

package cn.tedu.assertx;

import java.util.Scanner;

public class AssertDemo1 {
    public static void main(String[] args) {
        //请输入大于10的数
        System.out.println("请输入大于10的数！！！");
        //输入数据
        int num=new Scanner(System.in).nextInt();

        //
        num=num>>1;

        //预测结果
        //如果使用assert需要先开启断言
        //如果预测成功则正常运行如果预测不成功则报错---AssertionError
        assert num>5;

        //
        System.out.println(num);


    }
}

开启断言

线程
进程：操作系统上应用程序拆分成多个小任务
线程：进程拆分成多个小任务

在某个时刻，CPU的某个核中只能执行一个进程，进程可以拆分成多个线程，CPU的某个核中只能执行一个线程。CPU会轮换线程来执行。

多线程的好处

线程要么和CPU进制交互，要么和硬件进行交互，当线程和硬件进行交互时，CPU处于空闲时间。为了提高CPU利用率（理论上可以是100%）引入多线程。

创建多线程方式

1.继承Thread类重写run方法（线程执行任务信息），创建对象调用Thread类里start方法来开启线程
2.实现Runnable接口重写run方法（线程执行任务信息），由Runnable实现类对象来构建Thread类的对象来调用start方法开始线程

package cn.tedu.thread;

public class RunnableDemo {
    public static void main(String[] args) {
        //创建代表线程执行信息的类的对象
        RDemo r=new RDemo();
        //创建Thread类对象
        //Thread类和RDemo类都是Runnable的实现类
        //同类对象给本类对象增强功能---装饰者设计模式
        Thread t=new Thread(r);
        //调用start方法
        t.start();

        //主线程
        for (int i = 20; i >= 0; i--) {
            System.out.println("main:"+i);
            //
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


//定义类---代表线程执行任务信息
//类与接口是多实现，不影响实现别的接口
class RDemo implements Runnable{

    //重写方法---线程执行任务信息
    @Override
    public void run() {
        //
        for (int i = 0; i < 20; i++) {
            System.out.println("run:"+i);

            //休眠
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

package cn.tedu.thread;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class SellerTicketDemo1 {
    public static void main(String[] args) throws IOException {
        //加载配置文件
        Properties p=new Properties();
        p.load(new FileInputStream("ticket.properties"));
        //根据键来获取值
        String count=p.getProperty("count");

        //创建代表票的类的对象
        Ticket t=new Ticket();
        //设置初始票数
        t.setCount(Integer.parseInt(count));
        //创建代表线程执行信息的类的对象---四个售票员
        Seller s1=new Seller(t);
        Seller s2=new Seller(t );
        Seller s3=new Seller(t);
        Seller s4=new Seller(t);

        //创建四个线程对象（Thread）对象
        Thread t1=new Thread(s1,"A");
        Thread t2=new Thread(s2,"B");
        Thread t3=new Thread(s3,"C");
        Thread t4=new Thread(s4,"D");

        //调用start方法
        t1.start();
        t2.start();
        t3.start();
        t4.start();

        //主线程

    }
}

//定义类---代表线程执行任务信息（卖票）
class Seller implements Runnable{
    //代表票数---共卖100张票
    //static int count=100;
    //声明代表票的类的对象
    private Ticket t;

    //有参构造---保证创建的对象共享一个t对象
    public Seller(Ticket t){
        this.t=t;
    }



    //重写run方法---卖票过程
    @Override
    public void run() {
        //循环实现
        while (t.getCount()>0){
            //卖一张票---设置新的剩余票数
            t.setCount(t.getCount()-1);
            //输出
            //Thread.currentThread()---当前正在执行的线程对象
            System.out.println(Thread.currentThread().getName()
                    +"卖了一张票，还剩余"+t.getCount()+"张票...");
        }
    }
}

//代表票的类
class Ticket{
    //代表票数
    private int count;

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}

多线程之间存在相互抢占（CPU执行权—随机），抢占发生在代码的每一步，产生错误的数据问题，导致多线程数据并发安全问题。