Day17

已于 2022-03-23 11:33:40 修改
阅读量57 收藏
点赞数
分类专栏： JavaSE 文章标签： java
于 2022-02-12 17:45:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43645809/article/details/122899685
版权

Java中的线程可以分类：用户线程；守护线程

        正常创建的线程是用户线程

        守护线程与用户线程功能是一样的，去完成某件事情

        用户线程的工作做完后它就结束了，守护线程是等待所有的用户线程结束后，守护线程才会自动退出

        例如垃圾回收任务就是在一个守护线程中进行的

public class ThreadDemo extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

public class ThreadDemo1 extends Thread {
    @Override
    public void run() {
       while(true)
       {
           /*try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }*/
           System.out.println(Thread.currentThread().getName());
       }

    }
}

public class demo {
    public static void main(String[] args) {
        ThreadDemo t1 = new ThreadDemo();
        t1.setName("用户线程");
        t1.start();
        ThreadDemo1 t2 =new ThreadDemo1();
        t2.setName("守护线程");
        t2.setDaemon(true);//将线程设置为守护线程，必须在启动线程前设置，否则会报错
        t2.start();
    }
}

多线程

        在一个应用程序中可以有多个线程任务执行

        程序中同时需要执行多个任务时，就需要多个线程。例如360安全卫士

        多线程优点：

                提高程序速度

                提高了CPU的利用率

                改善程序结构

        多线程缺点：

                多线程对内存消耗增高

                多线程切换执行，对cpu的要求也提高了 这两个缺点可以通过升级硬件设备解决

                多个线程访问同一个共享资源，会出现线程安全问题

        出现线程安全问题：多线程且访问同一个共享资源（单一的多线程不会出现线程安全问题，每一个线程都在做自己的事情，没有交集）

        线程并行执行：多个人同时做不同的事情，互补干扰

        线程并发执行：在一段时间内依次执行某件事情，一个一个来做交替做、

        必须程序控制线程 并发执行 高并发 双十一 秒杀 抢购...

        卖票：买电影票 美图，支付宝，电影院 2.12 万达 1号 15：00 5排5号

        解决线程安全问题：加锁+排队 为出票加锁，一次只能有一个线程进入到出票的方法中。

        synchronized关键字 可以修饰代码块

        synchronized（同步锁对象）

        {

        }

        synchronized修饰方法 如果是非静态方法，那么锁对象是this；如果是静态方法，那么锁对象是类的Class对象

第一个的1和2是一个方法的不同写法，第二个的1和2也是，但是第一个和第二个方法不同，表达的意思相同

1.public class ticketThread_abck extends  Thread{
    static int num = 10;
    static Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            /*
             * synchronized(锁对象）锁对象可以是任何对象，但是必须是唯一的，也就是多个线程对应同一个锁对象
             * 在对象中，有一个区域叫对象头，对象头中有一个锁的标志为，无锁和已被使用
             * */
            synchronized (obj) {
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + num);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    num--;
                } else {
                    System.out.println("票卖完了");
                    break;
                }
            }
        }
    }
}
2.public class ticketThread  extends  Thread {
    static int num = 10;
    static Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            print();
            if(num == 0)
            {
                System.out.println("票卖完了");
                break;
            }
        }
    }
    /*
    synchronized 修饰方法时，锁对象默认是this
    synchronized 修饰的是static 方法，那么锁对象是类的class对象
    每一个类被加载到内存时，就会为类创建一个class类的对象，无论创建了多少个对象，class对象只有一个
    * */
    public static synchronized void print()
    {
        if (num > 0) {
            System.out.println(Thread.currentThread().getName() + ":" + num);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num--;
        }
    }
}
public class tickettext {
    public static void main(String[] args) {
        ticketThread t1 = new ticketThread();
        t1.setName("窗口1");
        t1.start();
        ticketThread t2 = new ticketThread();
        t2.setName("窗口2");
        t2.start();
    }
}

1.package Day17.ticket2;

public class TicketThread implements Runnable {
    int num =10;//这就是共享资源
    @Override
    public void run() {
        while(true)
        {
               print();
               if(num <= 0)
               {
                   System.out.println("票卖完了");
                   break;
                }
            }
        }
    public synchronized void print() {
        if (num > 0) {
            System.out.println(Thread.currentThread().getName() + ":" + num);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num--;
        }
    }
}
2.public class TickThread_back implements Runnable  {    int num =10;//这就是共享资源    @Override    public void run() {        while(true)        {            synchronized (this) {                if (num > 0) {                    System.out.println(Thread.currentThread().getName() + ":" + num);                    try {                        Thread.sleep(1000);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    num--;                } else {                    System.out.println("票卖完了");                    break;                }            }        }    }}

        synchronized是靠底层指令控制实现

        synchronized可以修饰代码块，修饰方法，注意锁对象（锁对象可能会变）。

        synchronized加锁方式是隐式的，进入到同步代码块时，自动获取锁 同步代码块执行完后，自动释放锁。

lock接口

        lock锁是靠Java代码来控制

        ReentrantLock类实现lock接口 可以来控制与synchronized相同的功能 但两者的实现细节完全不同的。

        lock加锁只能对某一段代码加锁 而且是显式的加锁和释放锁

import java.util.concurrent.locks.ReentrantLock;
public class TicketThread implements Runnable{
    int num = 10;//这就是共享资源
    ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {

                lock.lock();
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + num);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    num--;
                } else {
                    System.out.println("票卖完了");
                    break;
                }
            }finally {
                lock.unlock();//释放锁  尽量放在finally代码块中
            }
        }
    }
}
public class Test {
    public static void main(String[] args) {
        //创建一个出票任务
        TicketThread t = new TicketThread();//只创建了一个线程任务对象
        //支付宝 微信 不可能直接操作你的银行账号 向银行申请访问接口  实际操作的功能是银行
        Thread t1 = new Thread(t,"窗口1");
        t1.start();
        Thread t2 = new Thread(t,"窗口2");
        t2.start();
    }
}

线程死锁

        不同的线程分别占用对方需要的同步资源不放弃，

        出现死锁，发送死锁后不会报错，只是等待

        锁的嵌套时容易发生死锁

线程通信

        就是多个线程之前相互牵制，制约运行

        wait() 让线程等待,调用wait()方法后线程进入到阻塞阻塞状态，必须通过另一个线程唤醒

        notify() 唤醒等待中的线程

        notifyAll() 唤醒等待中所以线程

        这3个方法必须在同步代码中执行

                sleep()

                wait()

                        相同点：可以让线程进入到阻塞状态

                        不同点：

                                sleep() 是Thread类中的方法

                                不会释放锁

                                休眠时间到了后，会自动进入到就绪状态

                                wait（）是Object类中的方法

                                会释放锁

                                wait后的线程，需要使用notify/notifyAll唤醒

生产者和消费者问题

        两个线程之间相互牵制使用

        生产者线程

                                柜台中的商品 0

        消费者线程

/*
* 柜台*/
public class Counter {
    int num = 0;
    /*
    * 生产者调用
    * */
    public synchronized void jia(){
        if(num==0)
        {
            num++;
            System.out.println("生产者生产了一个商品");
            this.notify();
        }else
        {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /*
    * 消费者调用*/
    public synchronized void jian()
    {
        if(num==1)
        {
            num--;
            System.out.println("消费者取走了商品");
            this.notify();
        }else
        {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
/*
* 生产者*/
public class Productor  extends Thread{
    Counter counter;
    public Productor(Counter counter)
    {
        this.counter = counter;
    }
    @Override
    public void run() {
        while(true)
        {
            counter.jia();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
/*
* 消费者*/
public class Custom  extends Thread{
    Counter counter;
    public Custom(Counter counter)
    {
        this.counter = counter;
    }

    @Override
    public void run() {
        while(true)
        {
            counter.jian();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class test {
    public static void main(String[] args) {
        Counter counter =new Counter();//共享数据
        Productor productor = new Productor(counter);
        productor.start();
        Custom custom = new Custom(counter);
        custom.start();
    }
}

第三者创建线程的方式

        继承Thread 还是实现Runnable 最终都是重写run().

        run方法没有返回值，也不能抛出异常 就存在局限性

        java中推出了一个新接口 Callable 里面定义了一个Call（）方法 可以有返回值（使用泛型自定义），可以抛出异常

import java.util.concurrent.Callable;

public class SumThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
       int sum = 0;
       Thread.sleep(100);
        for (int i = 1; i <=10 ; i++) {
            sum+= i;
        }
        return sum;
    }
}
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class test {
    public static void main(String[] args) {
        SumThread sumThread = new SumThread();
        FutureTask<Integer> futureTask = new FutureTask(sumThread);
        Thread t = new Thread(futureTask);
        t.start();
        try {
            Integer sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

之和_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day17-case
Youmonster的博客
12-24 1735
用户信息列表管理系统 1.项目需求： 实现简单的用户增删改查功能 2.设计 1.技术选型：Servlet+JSP+MySQL+JDBCTemplate+druid+BeanUtils+Tomcat 2.数据库设计： create database day17; -- 创建数据库 use day17; -- 使用数据库 create table user( -- 创建表 id int primary key auto_increment, name varch
复试21天Day 17
薛定谔的猫的博客
03-14 5526
计算机复试题，包括数据结构，操作系统，计算机网络，计算机组成原理，数据库，软件工程，专业面试，英语面试等等，一共21天坚持更新，如果对你有帮助，欢迎点赞评论关注博主
CGBTN2110 DAY17复习总结
程序媛泡泡的博客
11-22 2978
1.多线程数据安全隐患解决方案 1. 出现数据安全问题的原因： 多线程程序 多个线程拥有共享数据 多条语句操作共享数据 2. 同步与异步 异步：是多个线程抢占资源的效果，不排队，所以效率高，但是数据不安全 同步：每次只有一个线程独占资源，排队，所以效率低，但是安全，为了安全必要应该牺牲一部分资源 synchronized也被称作同步关键字 3. 解决方案：加锁synchronized 同步代码块【常用】，格式： synchronized（唯一的锁对象）{ 可能出现数据安全问题的所有代码 } 4.使用同步
java第一阶段（day17）终篇
sunshine195的博客
03-20 734
...
黑码程序员-day17综合练习
MirroMirro的专栏
07-04 2911
android培训、java培训、期待与您交流！     //静态导入,使本练习中不再使用System或Arrays关键字 import static java.util.Arrays.*; import static java.lang.System.*; import java.util.*; class day17  { public static vo
【每日一题】备战冲击蓝桥杯国赛——Python程序设计 | Day17 | 杨辉三角 | 真题代码解析
车手只需要车和手，压力来自轮胎
03-12 4952
备战蓝桥杯，加入我们，一起来刷题，冲击国赛！！！
从零开始学习C语言日记——DAY17制作一个猜数字游戏
bearbearwww的博客
03-08 3909
一个猜数字游戏
【c++百日刷题计划】 ———— DAY17，刷题百天，养成刷题好习惯
Ceylan__的博客
08-17 839
【c++百日刷题计划】 ———— DAY17，刷题百天，养成刷题好习惯！！！
高等数学期末总复习DAY17.第一类曲面积分、第二类曲面积分、高斯公式、
马飞头秃了吗？
06-19 5392
DAY17. 文章目录DAY17.第一类曲面积分第二类曲面积分高斯公式 第一类曲面积分 对面积的曲面积分 形式：∬∑f(x,y,z)ds\iint_{\sum} f(x,y,z) d_s∬∑​f(x,y,z)ds​ 例题 求∬∑ds\iint_{\sum} d_s∬∑​ds​ 其中∑=2−(x2+y2)\sum = 2 - (x^2+y^2)∑=2−(x2+y2)在 xoy 平面上的部分 解： ∑\sum∑的区域画图为： 总体为一个圆锥体，其中投影面为S {z=0x2+y2⩽2\begin{cases}
mysql day_MySQL day()函数
weixin_34061241的博客
01-18 1129
在本教程中，您将学习如何使用MySQL DAY函数来获取指定日期的月份的日期(一个月的第几天，也就是表示月份多少日/号)。MySQL DAY函数简介DAY函数返回给定日期的月份的部分。下面显示DAY函数的语法：DAY(date);DAY函数接受一个参数，它是您要获取月份日期的日期值。如果date参数为零，例如'0000-00-00'，则DAY函数返回0，如果日期为，则DAY函数返回NULL值。请注...
配置Java开发环境
Broken_x的博客
07-10 1461
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 348
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 426
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2322
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1418
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java占位符替换五种方式
weixin_61478518的博客
07-08 546
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
elk部署springboot
Chihirozy的博客
07-11 249
elk部署springboot。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 3309
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
python bbs论坛_Python之路,Day17 - 分分钟做个BBS论坛
05-25
在 Day17 中，我们可以通过 Flask 框架快速搭建一个 BBS 论坛。具体步骤如下： 1. 创建 Flask 应用 ```python from flask import Flask app = Flask(__name__) ``` 2. 创建数据库 ```python from flask_sqlalchemy import SQLAlchemy app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///bbs.db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) ``` 3. 创建数据库模型 ```python class User(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(20), unique=True, nullable=False) password = db.Column(db.String(20), nullable=False) class Post(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(100), nullable=False) content = db.Column(db.Text, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) ``` 4. 创建路由和视图函数 ```python @app.route('/') def index(): posts = Post.query.all() return render_template('index.html', posts=posts) @app.route('/post/<int:post_id>') def post(post_id): post = Post.query.get(post_id) return render_template('post.html', post=post) @app.route('/new_post', methods=['GET', 'POST']) def new_post(): if request.method == 'POST': title = request.form['title'] content = request.form['content'] user_id = 1 # 假设当前用户为 id 为 1 的用户 post = Post(title=title, content=content, user_id=user_id) db.session.add(post) db.session.commit() return redirect('/') return render_template('new_post.html') @app.route('/login', methods=['GET', 'POST']) def login(): if request.method == 'POST': username = request.form['username'] password = request.form['password'] user = User.query.filter_by(username=username, password=password).first() if user: session['user_id'] = user.id return redirect('/') else: flash('用户名或密码错误') return render_template('login.html') @app.route('/logout') def logout(): session.pop('user_id', None) return redirect('/') ``` 5. 创建 HTML 模板 创建 index.html、post.html、new_post.html、login.html 四个模板文件，并且使用 jinja2 模板引擎渲染数据。 6. 运行应用 ```python if __name__ == '__main__': app.run() ``` 以上就是快速搭建 BBS 论坛的主要步骤，当然在实际应用中还需要考虑更多细节问题，比如用户认证、数据校验、页面美化等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值