2.13 笔记

最新推荐文章于 2024-07-29 18:00:00 发布
最新推荐文章于 2024-07-29 18:00:00 发布
阅读量73 收藏
点赞数
分类专栏： java小白 初学者笔记 文章标签： java 开发语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44811380/article/details/129005134
版权

6.14 多线程【java.lang】

应用程序：静态指令集。 例如：QQ、百度云盘。。。
进程：应用程序当运行时。开辟进程【内存】QQ后台进程
线程：进程中一个程序控制流
轻量级的进程【不用开辟内存】，CPU最小调度单元，进程中包含多个线程，这些线程协调工作，并发运行，即为多线程。

好处：

提高代码的运行效率，CPU调度效率高。
6.14.1 多线程的创建【※】
1. 继承java.lang.Thread


2. 实现接口 java.lang.Runnable


3. 线程池  java.util.concurrent.Callable

6.14.2 Thread类

public class Thread extends Object implements Runnable{

}

属性：

MAX_PRIORITY 最高优先级   10
MIN_PRIORITY 最低  1
NORM_PRIORITY  默认 5

构造：

new Thread() ;
new Thread(Runnable target) ;

方法：

方法名

含义

参数

返回值

run()

线程体: 该线程内容，不能直接调用run()

void

start()

线程启动，一个线程只需启动1次，就绪，自动调用run()

currentThread()

获得当前正在运行的线程

Thread

getName()

获得线程名

setName()

设置线程名

setPriority(优先级数字)

设置线程的优先级【1-10】

优先级

void

getPriority()

获得优先级

int

static sleep(毫秒)

线程休眠 throws InterruptedException

休眠时间

yield()

线程暂停

public class MyThread extends Thread{

    public MyThread() {
        super();
        // TODO Auto-generated constructor stub
    }

    public MyThread(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void run() {
        
        for (int i = 1; i <= 20; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }        
    }

}

public class TestThread {
    public static void main(String[] args) {
        System.out.println("主线程");
        MyThread t1 = new MyThread("甲线程");
        MyThread t2 = new MyThread("乙线程");
        t1.start();
        t2.start();
    }
}

售票练习：

public class TicketThread extends Thread{
    private int tickets = 100;
    
    @Override
    public void run() {
        while(true) {
            //线程体
            if(tickets == 0) {
                System.out.println("售空了");
                break;
            }
            else
                System.out.println(Thread.currentThread().getName() + "售出第" + (100 - --tickets) + "张票");
        }
        
    }
}
 
  
public class Test {
    public static void main(String[] args) {
        System.out.println("开放售票窗口");
        TicketThread t1 = new TicketThread("窗口1");
        //t1.setName("窗口1");
        
        TicketThread t2 = new TicketThread();
        t2.setName("窗口2");
        
        t1.start();
        t2.start();
    }
}

sleep和yield,wait:

sleep() 线程调用后，线程进入挂起，让出cpu给其他任意有需要的线程，当休眠时间到了，该线程进入就绪状态等待CPU的重新调度

yield() 线程暂停，让出CPU给比它优先级高的线程，直接进入就绪状态，一旦没有更高优先级，立刻抢占CPU。

wait() Object的方法，线程等待，需要手动唤醒

join() 加入线程，start()后设置，其他线程等他执行完再恢复

线程休眠：

public class WashigThread extends Thread{
    
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("清洗第" + i + "个杯子");
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("第" + i + "个杯子清洗完成");
        }
    }
}
public class BoilThread extends Thread{

    @Override
    public void run() {
        System.out.println("开始烧水.......");
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("水烧开了.....");
    }
    
}

public class TestThread {
    public static void main(String[] args) {
        BoilThread b = new BoilThread();
        WashigThread w = new WashigThread();
        
        b.start();
        w.start();
        
        System.out.println("客人来啦");
    }
}

6.14.3 线程的状态
开始状态
就绪状态
运行状态
阻塞状态【挂起】
结束状态

6.14.4 Runnable接口方式
public interface Runnable{
    void run();
}
1.实现类实现接口
2.匿名内部类
3.lambda 
public class TicketThread2 implements Runnable{
    private int tickets = 100;
    @Override
    public void run() {
        
        while(true) {
            //线程体
            if(tickets == 0) {
                System.out.println("售空了");
                break;
            }
            else
                System.out.println(Thread.currentThread().getName() + "售出第" + (100 - --tickets) + "张票");
        }
        
    }

}

测试：

public class Test2 {
    public static void main(String[] args) {
        TicketThread2 w1 = new TicketThread2();        
        Thread t1 = new Thread(w1);
        t1.start();
        
        TicketThread2 w2 = new TicketThread2();        
        Thread t2 = new Thread(w2);
        t2.start();
    }
}

匿名内部类写法：

new Thread(new Runnable() {
            private int tickets = 100;
            @Override
            public void run() {
                while(true) {
                    //线程体
                    if(tickets == 0) {
                        System.out.println("售空了");
                        break;
                    }
                    else
                        System.out.println(Thread.currentThread().getName() + "售出第" + (100 - --tickets) + "张票");
                }
            }
            
        }).start();

lambda写法：

new Thread(()->{
            int tickets = 100;
            while(true) {
                
                //线程体
                if(tickets == 0) {
                    System.out.println("售空了");
                    break;
                }
                else
                    System.out.println(Thread.currentThread().getName() + "售出第" + (100 - --tickets) + "张票");
            }
        }).start();
6.14.5 线程同步
 线程同步，线程安全，当A线程和B线程有共享数据资源【临界资源】时，A线程对共享数据资源访问时，B线程无法操作。造成程序执行效率低。速度慢。

 线程不同步，不安全，效率高，速度快，控制线程运行

1. 加锁 

   synchronized

   lock() 

 2. 避免临界资源

同步的两种形态：


1. 同步块
​
synchronized(临界资源){
锁定临界数据

}
​
2. 同步方法
​
public synchronized 返回值 方法(){

}

示例：

@Override
    public void run() {
        synchronized (card) {
            //10次 一次1000 当前余额
            for (int i = 1; i <= 10; i++) {
                card.setMoney(card.getMoney() + 1000);
                //显示
                System.out.println(Thread.currentThread().getName() + "存入1000元，当前余额：" + card.getMoney());
                
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }    
    }

改写：

public class TestCard {
    public static void main(String[] args) {
        BankCard card = new BankCard(5000);

        Thread t1 = new Thread(() -> {
            // 10次 一次1000 当前余额
            for (int i = 1; i <= 10; i++) {
                synchronized (card) {
                    card.setMoney(card.getMoney() + 1000);
                    // 显示
                    System.out.println(Thread.currentThread().getName() + "存入1000元，当前余额：" + card.getMoney());

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        });

        Thread t2 = new Thread(() -> {
            // 10次 一次1000 当前余额
            for (int i = 1; i <= 10; i++) {
                synchronized (card) {
                    if (card.getMoney() == 0) {
                        System.out.println("余额不足");
                    } else {
                        card.setMoney(card.getMoney() - 1000);
                        // 显示
                        System.out.println(Thread.currentThread().getName() + "取1000元，当前余额：" + card.getMoney());
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        });
        
        t1.setName("齐齐");
        t2.setName("玛丽");
        
        t1.start();
        t2.start();

    }
}

思考： 目前所学哪些类/接口 线程安全和不安全？

线程安全 不安全：
StringBuffer StringBuilder

Vector ArrayList /LinkedList

Hashtable HashMap

死锁现象：

两个线程，A线程占用B线程需要的资源不释放， 同时，B线程占用的A线程需要的资源也不释放，死锁。
6.14.6 线程通信
多个线程并发运行时，线程直接互相发送信号，以多线程的高效执行。

实现机制：

wait() 线程等待

notify()
notifyAll() 唤醒

经典案例：生产者 消费者模型

当生产者生产过多仓库库存， 线程等待，唤醒消费者消耗产品
当消费者发现库存清0 ，线程等待，唤醒生产者生产产品 
/**
    仓库
*/
public class Clerk {
    //产品 
    private int product;
    
    public Clerk(int product) {
        super();
        this.product = product;
    }

    /**
     * 生产
     */
    public synchronized void produce() {
        if(product >= 20) {
            //别生产
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else {
            product ++;
            System.out.println(Thread.currentThread().getName() + "生产产品，当前库存:" + product);
            notifyAll();
        }
    }
    
    /**
     * 消耗
     */
    public synchronized void consume() {
        if(product <= 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else {
            product --;
            System.out.println(Thread.currentThread().getName() + "消耗产品，当前库存:" + product);
            notifyAll();
        }
    }
}
/**
    生产者线程
*/
public class ProductThread implements Runnable{    
    private Clerk c;

    public ProductThread(Clerk c) {
        super();
        this.c = c;
    }

    @Override
    public void run() {
        while(true) {
            c.produce();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

/**
消费者
*/

public class ConsumerThread implements Runnable{
    
    private Clerk c;

    public ConsumerThread(Clerk c) {
        super();
        this.c = c;
    }

    @Override
    public void run() {
        while(true) {
            c.consume();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

public class Test {
    public static void main(String[] args) {
        Clerk c = new Clerk(0);
        //生产者
        new Thread(new ProductThread(c),"生产者1").start();
        new Thread(new ProductThread(c),"生产者2").start();
        //消费者
        new Thread(new ConsumerThread(c),"消费者").start();
    }
}
6.14.7 线程池
线程池： 缓冲N个即将运行的线程为多个任务提供服务，减少每次的创建以及销毁开销，达到线程高效利用。

使用：

Executors 工厂类  创建线程池的
ExecutorService 线程池提供服务的对象 ，接收任务
    提交任务
    submit(Runnable r) // lang run() 无返回值  无异常抛出
    submit(Callable c) // util call() 有返回值
    shutdown()  不再接收任务

Future 获得结果的接口
    get();

线程池：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestPool {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService service = Executors.newFixedThreadPool(3);
        //提交任务1
        Future<Integer> res1 = service.submit(new Callable<Integer>() {

            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 50; i++) {
                    sum += i;
                }
                return sum;
            }
        });
        
        Future<Integer> res2 = service.submit(()->{
            int sum = 0;
            for (int i = 51; i <= 100; i++) {
                sum += i;
            }
            return sum;
        });
        try {
            System.out.println(res1.get() + res2.get());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        service.shutdown();
    }
}

第七章 JDK8+新特性

概述新特性：
jdk8 和jdk5一样，是里程碑版本，2014年发布，新特性。
7.1 接口的改变
// 非抽象的默认方法，所有实现类相同，无序重写的
public interface Fly {
    
    //起飞
    void takeOff();
    
    //着陆
    //默认方法
    default void land() {
        System.out.println("着陆了");
    }
}

//接口自己使用的静态方法
public interface Fly {
    
    //静态方法
    static void tool() {
        System.out.println("飞行工具使用");
    }
}
7.2 String新增
join(”连接符“，数组) 
split("分隔符")
    
    
 public static String hide(String ip) {
        String[] a = ip.split("\\.");
        a[a.length - 1 ] = "*";
        return String.join(".", a);
    }
7.3 lambda
特殊的匿名内部类，语法更加简单。 
函数式接口 对象 = (参数变量1,参数变量2...) ->{
    //方法体;
};

函数式接口的特点：

1. 可以有多个非抽象方法，但有且只要一个抽象方法
2. 一般用于标志，起到编译时的规范作用，添加注解： @FunctionalInterface

表达式特点：

1.参数列表类型无需指定，自动推算
2.没有参数的只需()
3.如果只要一个参数，可省略()
4.返回值只要一句话，return {}可以省略
7.4 常用的函数式接口
public class TestLa2 {
    public static void main(String[] args) {
        //消费型接口
        Consumer<String> c = t -> System.out.println("该名字长度:" + t.length());        
        c.accept("jackson");
        //1-16一个
        //供给型
        Supplier<Integer> s = () -> (int)(16 * Math.random() + 1);    
        System.out.println(s.get());
        
        //函数式
        Function<String, Integer> f = t -> t.length();
        System.out.println(f.apply("jack"));
        
        //断言接口
        Predicate<String> p = n -> n.endsWith(".txt");    
        System.out.println(p.test("E:\\1.txt"));
    }
}
7.5 Stream
Stream作用简化对数组以及集合的操作【筛选，求和，过滤，排序，最大值，计数....】

原理：

//1 转化成Stream
集合对象.stream()

//2. 案例
public class TestStream {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(10,45,10,67,36,90,45);
        
        list = list.stream().distinct().sorted().collect(Collectors.toList());
        
        list.forEach(t -> System.out.println(t));
    }
}

SmartWindowsComen
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2023-04-06-项目笔记-第十五阶段-课前3个分享 4.4变量的作用域与生命周期 4.4.2.13全局变量的作用域-13
01-17
2023-04-06-项目笔记-第十五阶段-课前小分享_小分享1.坚持提交gitee 小分享2.作业中提交代码 小分享3.写代码注意代码风格 4.3.1变量的使用 4.4变量的作用域与生命周期 4.4.1局部变量的作用域 4.4.2全局变量的作用域 ...
PDF拆分工具 DjVuToy v2.13
10-29
比如，图书馆员可以使用它来整理大量的扫描书籍，研究人员可以方便地拆分和合并文献资料，学生则可以轻松地提取课程笔记。对于那些需要处理大量文档的专业人士来说，这个工具无疑是一个宝贵的助手。 总的来说，...
2.13笔记
weixin_43182648的博客
02-16 80
1.EJB(企业级JavaBean)的优点：性能优越和强大的容器支持 2.lib目录下放置.jar 文件 3.ServletConfig获得Servlet的初始化参数 4.HttpServletRequest用于获得浏览器发送的请求 5.运行.jsp 需要安装tomcat、WebLogic Web服务器 6.在服务器的网络编程中，解决会话跟踪的方法有：Cookie、URL重写、隐藏表单域 7.在S...
2.13Java基础学习笔记
suzuran7的博客
02-13 1231
Super T> c)用Comparator接口实现自定义排序规则。
java笔记2.13
qq_46664420的博客
06-15 72
Math类不可以实例化，只能通过Math类名调用其中的静态方法 因为math类的构造是private访问权限 System类 System.currentTimeMillis() System.exit(0);根据currentTimeMillis()计算当前时间 object类 所有类都之间或者间接继承object类，它是所有类的超类 由于多态，所有类都可以由object类，达到多态的效果 所以所有类都有tostring方法，也都包含object中的成员方法......
SVG学习笔记
qq_45660256的博客
07-02 634
/svg>
信号基础笔记
wjlo1的博客
06-26 722
信号是发生事件时对进程的一种通知机制。
Linux学习笔记
weixin_74155781的博客
05-25 2469
计算机由哪两个主要部分组成硬件和软件操作系统是什么?由什么作用?操作系统是软件的一类。主要作用是协助用户调度硬件工作，充当用户和计算机硬件之间的桥梁常见的操作系统有哪些?PC端: windows、Linux、MacOs移动端:Android、IOS、鸿蒙系统什么是虚拟机？借助虚拟化技术，我们可以在系统中，通过软件：模拟计算机硬件，并给虚拟硬件安装真实的操作系统。这样就可以在电脑中，虚拟出一个完整的电脑，就可以得到一个Linux系统。
LINUX命令笔记
fg_bear的博客
09-11 43
查看系统进程：ps -ef(-aux) | grep ’ ’ 杀死进程：kill -s 9 [pid] 批量处理文件： 删除前询问： ls |grep learning-pen-web.*.zip | xargs -p sudo rm 遍历删除： ls |grep learning-pen-web.*.zip | xargs -i sudo rm {} 筛选数据追加到文件：sudo bash -c “less /data/logs/log.* | grep 搜索文本 > /data/logs/1.
鸿蒙星河NEXT学习笔记
早日成为鹏总
06-27 510
/ 1. 定义接口// 2. 基于接口，定义对象name: '大幂幂',age: 18,weight: 90// 3. 获取对象属性值 对象名.属性名console.log('体重:', ym.weight)@Componentbuild() {Row() {Button('按钮')})@Componentbuild() {Row() {Text('我是头部')@Componentbuild() {Column() {// 将相同的业务逻辑, 封装成一个通用的组件。
kafka系列笔记（二）--
third_的博客
06-04 130
kafka系列笔记（二）--
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 251
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1009
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 95
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 543
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
26.jdk源码阅读之ConcurrentLinkedQueue
最新发布
前端、移动端、后端源码级底层原理分享
07-29 580
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
avrdudess2.13
01-18
avrdude 2.13是avrdude软件的一个版本，它可能包含了改进或修复了先前版本中的一些bug。使用avrdude 2.13可以更稳定地烧录程序到AVR微控制器中，也可以更方便地读取、擦除和管理微控制器的内容。 avrdude 2.13可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值