JAVA基础结束 2022.1.4----截至至String类的增删改查

最新推荐文章于 2024-10-31 15:56:11 发布

Etherstrings

最新推荐文章于 2024-10-31 15:56:11 发布

阅读量141

点赞数

分类专栏： Justice 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/Etherstrings/article/details/122295306

版权

Justice 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

57真的很累

每天任务都不少更想着需要加紧每天的论文理论的学习

唉！好累啊！！！

上回讲到构建线程的两种方式

这回接着说顺便当整理一遍了

55.线程的生命周期

new

就绪

运行 ---------》阻塞

死亡

56.线程的同步 ---------锁

why？同票错票

A执行时某代码块时 B也进来了

Slove?

执行代码块或者方法时

只能有一个线程进入

//直接声明方法为线程安全方法
    public synchronized void run(){
}


//1.方法上锁
class  Bank{
    private Bank(){}

    private static Bank instatnce=null;

    public static  synchronized Bank getInstatnce(){
        if(instatnce==null){
            instatnce=new Bank();
        }
        return instatnce;
    }
}
//2.代码块加锁
class  Bank1{
    private Bank1(){}

    private static Bank1 instatnce=null;

    public static   Bank1 getInstatnce(){
        synchronized (Bank1.class) {
            if (instatnce == null) {
                instatnce = new Bank1();
            }
        }
        return instatnce;
    }

//解决线程的安全问题
    方法中加锁
public class SynchronizedTest {
    public static int num=100;
    public static  void main(String[] args){


    Window w=new Window();
    Thread w1=new Thread(w);
    Thread w2=new Thread(w);
    Thread w3=new Thread(w);
    w1.start();
    w2.start();
    w3.start();

}
}

class Window implements Runnable{
    @Override
    public void run() {
        synchronized(this){


        while(true){
            if(SynchronizedTest.num>0)
            {System.out.println("卖票"+Thread.currentThread().getName()+SynchronizedTest.num);
                SynchronizedTest.num--;}
                else{break;}


        }
        }
    }
}

57.重写单例模式中懒汉模式——解决线程不安全

58.死锁问题

双方都等对方释放锁

59.锁—————Lock.lock();

实例化锁一个对象就行

Privtae Reentrantlock lock=new ......(true/false);

try{

lock(); }

final{

unlock(); }

60.创建线程的4种方式！

-----1.implementes Runnbale 接口

A implementes Runnbale

重写run()

A a=new A();

Thread b=new Thread(a);

b.start;

-------2.extends Thread 类

A extends Thread

重写run();

主方法中new A对象a

直接a.start();

---------3.implementes Callable 接口----------可返回异常值

A implementes Callable

重写run()

A a=new A();

Thread b=new Thread(a);

b.start;

------------4.线程池工作中常用

class NumberThread implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //ExecutorService     Executors
        //1.提供指定线程数量的线程池
        ExecutorService service=Executors.newFixedThreadPool(10);
        //2.执行指定的线程的操作。需要Runnable的实现类的对象或者Callable实现类的对象；
        service.execute(new NumberThread());
        //3.关闭线程池
        service.shutdown();
    }
}

60.线程通信-----------重要思路

主要思考

wait();

notify()；用法 ----------唤醒除本身外另一个线程

必须唤醒否则都停滞

例如：a和b线程轮番输出1个

class DoLine implements Runnable{
    private int num=1;
    @Override
    public synchronized void run() {

        while (true) {

                notify();
                if (num < 100) {
                    System.out.println(Thread.currentThread().getName() +":"+ num);
                    num++;
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }

        }
    }
}

public class LineTest {
    public static void main(String[] args) {
        DoLine doLine=new DoLine();
        Thread t1=new Thread(doLine);
        Thread t2=new Thread(doLine);
        t1.setName("Line 1");t2.setName("Line 2");
        t1.start();t2.start();
    }
}

61.生产者和消费者的思考

+1就可以-1

a，b生产时，不要让一个都进不来

class Clerk{
    private int num=0;

    public synchronized void produce(){
        if(num<20){
            num++;
            System.out.println(Thread.currentThread().getName()+"生产了1个，还剩："+num);
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    public synchronized void buy(){
        if(num>0){
            num--;
            System.out.println(Thread.currentThread().getName()+"取走了了1个，还剩："+num);
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


}

class Productor extends Thread{
    private Clerk clerk;
    //确保传入的店员为同一个店员
    //构造器极其关键，不要忘记了，可以给定对应的参数！！！！！！
    public Productor(Clerk clerk){
        this.clerk=clerk;
    }

    @Override
    public  void run() {
        while(true){
            try {
                sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produce();}
    }
}

class Customer extends Thread{
    private Clerk clerk;
    public Customer(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public   void run() {
        while(true){
            clerk.buy();
        }
    }
}
public class PandCTest {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();
        Productor p= new Productor(clerk);
        Customer c=new Customer(clerk);
        p.setName("Producer");
        c.setName("Buyer");
        p.start();
        c.start();
    }
}

62.slee() 和 wait() 的区别

最重要的是

sleep 不放锁进停滞时间

wait 放锁进来的是别线程！

63. 接下来开始的是对String类的详细解释

底层为 final char[]----------------不可变 final了还怎么变

str="a"-------------------------直接在常量池中的"a"

64.String类的方法

str="Jillina"

str.intlength() 长度

str.charAt(1) ---------------i

isEmpty