Java基础9-死锁;String;编码

昨日内容回顾

  1. 死锁案例

     class DeadLock{
         public static void main(String[] args){
             Pool pool = new Pool();
             Producer p1 = new Producer("p1",pool);
             Consumer c1 = new Consumer("c1",pool);
             Consumer c2 = new Consumer("c2",pool);
             p1.setName("p1");
             c1.setName("c1");
             c2.setName("c2");
    
             p1.start();
             c1.start();
             c2.start();
         }
     }
    
     class Producer extends Thread{
         String name;
         Pool pool;
         public Producer(String name, Pool pool){
             this.name = name;
             this.pool = pool;
         }
    
         public void run(){
             while(true){
                 pool.add();
             }
         }
     }
    
     class Consumer extends Thread{
         String name;
         Pool pool;
         public Consumer(String name, Pool pool){
             this.name = name;
             this.pool = pool;
         }
         public void run(){
             while(true){
                 pool.remove();
             }
         }
     }
    
     class Pool{
         private int MAX=1;
         private int count;
         public synchronized void add(){
             String name = Thread.currentThread().getName();
             while(count>=MAX){
                 try{
                     System.out.println(name+":"+"wait()");
                     this.wait();
                 }
                 catch(Exception e){}
             }
             System.out.println(name+":"+(++count));
             System.out.println(name+":"+"notify()");
             this.notify();
         }
    
         public synchronized void remove(){
             String name = Thread.currentThread().getName();
             while(count
  2. 同步方法中,wait()与notify()执行流程

     class WaitDemo{
         public static void main(String[] args){
             Cave cave = new Cave();
             Car c1 = new Car("奔驰",cave);
             Car c2 = new Car("宝马",cave);
             c1.start();
             c2.start();
    
             try{
                 Thread.sleep(5000);
                 synchronized(cave){
                     cave.notifyAll();
                 }
             }
             catch(Exception e){}
         }
     }
    
     class Cave{
     }
     class Car extends Thread{
         private String name;
         private Cave cave;
         public Car(String name, Cave cave){
             this.name = name;
             this.cave = cave;
         }
    
         public void run(){
             synchronized(cave){
                 System.out.println(name+"进洞了!");
                 try{
                     cave.wait();
                 }
                 catch(Exception e){}
                     System.out.println(name+"wait后代码");
             }
         }
     }
    
  3. 设置线程优先级

     class WaitDemo{
         public static void main(String[] args){
             Cave cave = new Cave();
             Car c1 = new Car("奔驰",cave);
             Car c2 = new Car("宝马",cave);
         
             //设置线程优先级
             Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
             c1.setPriority(Thread.MIN_PRIORITY);
             c2.setPriority(Thread.NORM_PRIORITY);
             System.out.println("c1.priority:"+c1.getPriority());
             System.out.println("c2.priority:"+c2.getPriority());
             System.out.println("main.prio : " +Thread.currentThread().getPriority());
         
             c1.start();
             c2.start();
    
             try{
                 Thread.sleep(5000);
                 synchronized(cave){
                     cave.notifyAll();
                 }
             }
             catch(Exception e){}
         }
     }
    
     class Cave{
     }
     
     class Car extends Thread{
         private String name;
         private Cave cave;
         public Car(String name, Cave cave){
             this.name = name;
             this.cave = cave;
         }
         
         public void run(){
             synchronized(cave){
                 System.out.println(name+"进洞了!");
                 try{
                     cave.wait();
                 }
                 catch(Exception e){}
                 System.out.println(name+"wait后代码");
             }
         }
     }
    

作业讲解

  1. 一共100个馒头,40个工人,每个工人最多能吃3个馒头,使用多线程输出所有工人吃馒头的情况

     class ThreadDemo{
         public static void main(String[] args){
             Basket basket = new Basket();
             Worker w[] = new Worker[40];
             for(int i=0;i<40;i++){
                 w[i] = new Worker("worker-"+i,basket);
             }
             for(int i=0;i<40;i++){
                 w[i].start();
             }
         }
     }
    
     //放馒头的篮子
     class Basket{
         private int No = 100;
    
         //取馒头
         public int getNo(){
             if(No<=0){
                 return -1;
             }
             else{
                 return No--;
             }
         }
     }
    
     //工人线程类
     class Worker extends Thread{
         private static Basket basket;
         private String name;
         private int sumNo=0;//总共吃的馒头数
    
         public Worker(String name,Basket basket){
             this.basket = basket;
             this.name = name;
         }
    
         public void run(){
             while(true){
                 synchronized(basket){
                     if(sumNo>=3){
                         return;
                     }
                     int no = basket.getNo();
                     if(no==-1){
                         return;
                     }
                     else{
                         sumNo++;
                         System.out.println(name+"吃了第"+no+"个馒头,共吃了"+sumNo+"个馒头");
                     }    
                 }
                 Thread.yield();
             }    
         }
     }
    
  2. 5辆汽车过隧道,隧道一次只能通过一辆汽车。每辆汽车通过时间不固定,
    机动车通过时间3秒,三轮车通过时间5秒,畜力车通过时间10秒,5辆车分别是2辆机动车,2辆畜力车,1辆三轮车,通过多线程模拟通过隧道的情况。提示:Car ThreeCar CowCar

     class ThreadDemo{
         public static void main(String[] args){
             Cave cave = new Cave();
             new Car(cave,"汽车1",3).start();
             new Car(cave,"汽车2",3).start();
             new ThreeCar(cave,"三轮车",5).start();
             new CowCar(cave,"畜力车1",10).start();
             new CowCar(cave,"畜力车2",10).start();
         }
     }
    
     //隧道,山洞
     class Cave{
     }
    
     //机动车线程类
     class Car extends Thread{
         private Cave cave;
         private int sec;
         private String name;
    
         public Car(Cave cave, String name, int sec){
             this.cave = cave;
             this.name = name;
             this.sec = sec;
         }
    
         public void run(){
             synchronized(cave){
                 System.out.println(name+"进洞了!"+new java.util.Date());
                 try{
                     Thread.sleep(sec*1000);
                 }
                 catch(Exception e){}
                 System.out.println(name+"出洞了!"+new java.util.Date());
             }
         }
     }
    
     //三轮车线程类
     class ThreeCar extends Thread{
         private Cave cave;
         private int sec;
         private String name;
    
         public ThreeCar(Cave cave, String name, int sec){
             this.cave = cave;
             this.name = name;
             this.sec = sec;
         }
         public void run(){
             synchronized(cave){
                 System.out.println(name+"进洞了!"+new java.util.Date());
                 try{
                     Thread.sleep(sec*1000);
                 }
                 catch(Exception e){}
                 System.out.println(name+"出洞了!"+new java.util.Date());
             }
         }    
     }
    
     //畜力车线程类
     class CowCar extends Thread{
         private Cave cave;
         private int sec;
         private String name;
    
         public CowCar(Cave cave, String name, int sec){
             this.cave = cave;
             this.name = name;
             this.sec = sec;
         }    
    
         public void run(){
             synchronized(cave){
                 System.out.println(name+"进洞了!"+new java.util.Date());
                 try{
                     Thread.sleep(sec*1000);
                 }
                 catch(Exception e){}
                 System.out.println(name+"出洞了!"+new java.util.Date());
             }
         }
     }    
    
  3. 用多线程模拟蜜蜂和熊的关系
    蜜蜂是生产者,熊是消费者,蜜蜂生产蜂蜜是累加的过程,熊吃蜂蜜是批量(满20吃掉)的过程,生产者和消费者之间使用通知方式告知对方,注意不能出现死锁现象。
    100只蜜蜂,每次生产的蜂蜜是1
    熊吃蜂蜜是20(批量的情况)

     class ThreadDemo{
         public static void main(String[] args){
             Pot pot = new Pot();
             for(int i=1;i<=100;i++){
                 new Bee("蜜蜂-"+i,pot).start();
             }
             new Bear("熊大",pot).start();
             new Bear("熊二",pot).start();
         }
     }
     //蜜罐
     class Pot{
         private int MAX = 20;//最大值
         private int count;//当前量
    
         //添加蜂蜜,+1
         public synchronized int add(){
             while(count >= MAX){//若是if则下次进入线程,就不再去判断,存在问题
                 try{
                     this.notifyAll();
                     this.wait();
                 }
                 catch(Exception e){
                     e.printStackTrace();
                 }
             }
             return ++count;
         }
    
         //移除蜂蜜,-MAX
         public synchronized void remove(){
             while(count< MAX ){
                 try{
                     this.wait();
                 }
                 catch(Exception e){
                     e.printStackTrace();
                 }
             }
             count=0;
             this.notifyAll();
         }
     }
     //蜜蜂,生产者线程类
     class Bee extends Thread{
         private Pot pot;
         private String name;
         public Bee(String name, Pot pot){
             this.name = name;
             this.pot = pot;
         }
         public void run(){
             while(true){
                 int n = pot.add();
                 System.out.println(name+"生产了:"+n);
             }
         }
     }
     //熊,消费者线程类
     class Bear extends Thread{
         private Pot pot;
         private String name;
         public Bear(String name, Pot pot){
             this.name = name;
             this.pot = pot;
         }
         public void run(){
             while(true){
                 pot.remove();
                 System.out.println(name+"吃掉了蜂蜜:20!");
             }
         }
     }
    

创建线程的方式

  1. 继承Thread类

  2. 实现Runnable接口{public void run();}

     class Man extends Person implements Runnable{
         public void run(){
         ...
         }
     }
    
     new Car().start();
     new Thread(new Man()).start();
    

java.lang.Runnable

  1. 接口

  2. public void run();

  3. 供现有类实现线程功能

  4. 使用Runnable对象创建线程

  5. 静态同步方式是使用class作为锁

  6. 非静态同步方式是使用当前对象作为锁

     new Thread(Runnable r).start();
     class Car implements Runnable{
     ...
     //静态同步方法
     static synchronized void xxx(){
    
     }
     }
     new Thread(Runnable r).start()
    

IDE

集成开发环境, integrate development environment
eclipse 快捷键:

  • alt + / //代码辅助
  • alt + 上箭头 //向上移动一行
  • alt + 下箭头 //向上移动一行
  • alt + shift + 上箭头 //向上复制一行
  • alt + shift + 下箭头 //向下复制一行
  • ctrl + D //删除一行
  • ctrl + shift + / //多行注释

String

  1. 常量

     String str = "xxx";
     str = "ddd";
     for(i<10000){
       name = name + "" + i;
     }//堆溢出
     byte b = (int)1234;
     //int a = (int)"123";
     //String name = (String)123;
     String name = 123 + "";
    
     Object o = new Dog();
     Dog d = (Dog)o;
    
  2. 创建String 的区别

     //一个对象
     String str1 = "abc";//在字符串池中开辟了空间
     //两个对象
     String str2 = new String("abc");//在堆区分配了内存空间
    
  3. split(String s) // 按照指定的字符切割字符串,形成String数组

     "hello,,,world,".split(",");//最后的,不会生效
    
  4. == //判断是否是同一对象。判断对象的内存地址

  5. equals //是判断两个对象内容是否相同。

  6. substring(int start) //取子串,包含start

  7. substring(int start,int end) //取子串,前包后不包

  8. 重写subString(String src,int beginIndex,int length) //按索引及长度取子串,要有健壮性

     public static String subString(String src, int beginIndex, int length) throws Exception {
         if(src==null) {
             throw new Exception("源串为空");
         }
         if(!(beginIndex>=0 && beginIndex0 && (beginIndex+length)<=src.length())) {
             throw new Exception("长度无效");
         }
         return src.substring(beginIndex,beginIndex+length);
     }
    

包装类

  1. byte Byte

  2. short Short

  3. int Integer

  4. long Long

  5. float Float

  6. double Double

  7. char Character

  8. boolean Boolean

自动装箱:Integer i = 12; // Integer i = new Integer(12);
自动拆箱:Integer i =12; i++

包装类与基本数据类型区别

  1. 包装类是对象,默认值是null;

  2. 数字型基本数据类型默认是0;

  3. 基本数据类型可以直接参与运算;

编码初始

电报,电脑的传输,存储都是01010101

0000110 晚
1010100 上
0010100 喝
0010111 点
0000001 儿

000010 1010100 0010100 0010111 0000001

最早的'密码本'

  1. ascii
    7位二进制,涵盖了英文字母大小写,特殊字符,数字。
    01000001 A
    01000010 B
    01000011 C
    ascii,一个字节最多8位, 只能表示256种可能,太少

  2. 存储单位换算
    1bit 8bit = 1byte
    1byte 1024byte = 1KB
    1KB 1024kb = 1MB
    1MB 1024MB = 1GB
    1GB 1024GB = 1TB

  3. 万国码 unicode

    • 起初:
      1个字节可以表示所有的英文,特殊字符,数字等等
      2个字节,16位表示一个中文,不够,unicode一个中文用4个字节,32位
      你 00000000 00000000 00000000 00001000

    • Unicode 升级 utf-8 utf-16 utf-32
      utf-8 一个字符最少用8位去表示:
      1). 英文用8位 一个字节
      2). 欧洲文字用16位去表示 两个字节
      3). 中文用24位去表示 三个字节
      utf-16 一个字符最少用16位去表示

  4. gbk
    中国人自己发明的,一个中文用两个字节,16位表示。

     String str = "a中b国c";
     byte[] bytes = str.getBytes("iso8859-1");
     System.out.println(bytes.length); //5, 欧洲码,没有中文字典
     System.out.println(new String(bytes,"iso8859-1")); //a?b?c
     
     bytes = str.getBytes("gbk");
     System.out.println(bytes.length); //7,一个字节表示英文字母,两个字节表示一个中文
     System.out.println(new String(bytes,"gbk")); //a中b国c
     
     bytes = str.getBytes("utf-8");
     System.out.println(bytes.length);//9, 英文一个字节,中文三个字节
     System.out.println(new String(bytes,"utf-8"));
    
     bytes = str.getBytes("unicode");// -2 -1 0 97 78 45 0 98 86 -3 0 99
     System.out.println(bytes.length);//12,中文四个字节,英文一个字节?为何是12?
     System.out.println(new String(bytes,"unicode"));
     
     String str2 = "a";
     byte[] bytes2 = str2.getBytes("unicode");//-2 -1 0 97
    
     String str3 = "中";
     byte[] bytes3= str3.getBytes("unicode");//-2 -1 78 45
     
     String str4 = "b";
     byte[] bytes4 = str4.getBytes("unicode");//-2 -1 0 98
      
     String str5 = "国";
     byte[] bytes5 = str5.getBytes("unicode");//-2 -1 86 -3
     
     String str6 = "c";
     byte[] bytes6 = str6.getBytes("unicode");//-2 -1 0 99
    

作业

  1. substring(String str, int beginIndex, int length);
    返回一定长度的子串

  2. 找到自己名字对应的Unicode码

你可能感兴趣的:(Java基础9-死锁;String;编码)