Day16

最新推荐文章于 2024-02-21 21:08:23 发布
最新推荐文章于 2024-02-21 21:08:23 发布
阅读量90 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuanlcj/article/details/113920689
版权
本文介绍了Java中线程的状态观测、线程优先级、守护线程、线程同步以及并发问题的解决方案，包括死锁、锁机制、线程池和生产者消费者模式。通过实例展示了如何避免线程不安全，以及使用JUC（Java并发工具包）提高并发性能。
摘要由CSDN通过智能技术生成

线程状态观测

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o77cBFa2-1613899142582)(D:\date img\QQ截图20210220082747.png)]

package com.duoXianCheng.stop;
/*
    观察测试线程的状态
 */
public class TextState {

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);//睡眠
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("///");
        });
        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);

        //观察启动后
        thread.start();
        state=thread.getState();
        System.out.println(state);

        while (state!=Thread.State.TERMINATED){//如果线程不停止就一直输出状态
            state=thread.getState();
            System.out.println(state);//更新状态
        }
        //一旦线程结束就不能在重新启动
        //  thread.start();
    }
}

线程优先级

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-14p0vFse-1613899142584)(D:\date img\QQ截图20210220084538.png)]

优先级低只意味着获得调度的概率低，并不是优先级低就不会被调用了，者都是看CPU调度

package com.duoXianCheng.stop;
/*
    线程优先级
 */
public class TextPriority {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();
        Thread thread1 = new Thread(myPriority);
        Thread thread2 = new Thread(myPriority);
        Thread thread3 = new Thread(myPriority);
        Thread thread4 = new Thread(myPriority);
        Thread thread5 = new Thread(myPriority);
        Thread thread6 = new Thread(myPriority);

        thread1.start();
        thread2.setPriority(9);//设置优先级   优先级高不一定先执行，需要看CPU调度
        thread2.start();
        thread3.setPriority(3);
        thread3.start();
        thread4.setPriority(7);
        thread4.start();
        thread5.setPriority(1);
        thread5.start();
        thread6.setPriority(Thread.MAX_PRIORITY);
        thread6.start();

    }
}
class MyPriority implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

守护线程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rVEJBgN5-1613899142586)(D:\date img\QQ截图20210220091125.png)]

package com.duoXianCheng.stop;
/*
    守护线程
        当线程结束后，守护线程之后也会结束
 */
public class TextDaemon {
    public static void main(String[] args) {
        You you = new You();
        God god = new God();
        Thread thread = new Thread(god);
        thread.setDaemon(true);
        thread.start();
        new Thread(you).start();
    }
}
class You implements Runnable{
    @Override
    public void run() {
        for (int i = 100; i >=0; i--) {
            System.out.println("you have"+i+"years");
        }
        System.out.println("good bye world");
    }
}
class God implements Runnable{
    @Override
    public void run() {
        while(true) {
            System.out.println("i am god daemon you");
        }
    }
}

线程同步

多个线程操作同一个资源

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xDzmvTRf-1613899142589)(D:\date img\QQ截图20210220095740.png)]

线程不安全案例一

package com.duoXianCheng.syn;
/*
    模拟不安全的买票
        会出现线程不安全的问题，出现负数票
 */
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"1").start();
        new Thread(buyTicket,"2").start();
        new Thread(buyTicket,"3").start();
    }
}
class BuyTicket implements Runnable{
    //需要定义有几张票
    private int ticket=10;
    //使用外部停止
    private boolean flg=true;
    @Override
    public void run() {
        while (flg){
            System.out.println(Thread.currentThread().getName()+"抢到了第"+ticket--+"张票");
            if (ticket<=0){
                flg=false;
            }
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //

}

线程不安全案例二

package com.duoXianCheng.syn;
/*
    模拟银行取钱
   		取前为负数
 */
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account("account", 300);
        new Thread(new Bank(account,200,"you "),"you").start();
        new Thread(new Bank(account,300,"girlfriends "),"girlfriends").start();
    }
}
//账户
class Account{
   String name;
   int money;

    public Account(String name, int money) {
        this.name = name;
        this.money = money;
    }
}
//bank
class Bank extends Thread{
    Account account;
    private int quMoney;
    private int nowMoney;

    public Bank(Account account, int quMoney, String name) {
        super(name);
        this.account = account;
        this.quMoney = quMoney;


    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (account.money<quMoney){
            System.out.println(Thread.currentThread().getName()+"账户余额不足");
            return;
        }
        account.money=account.money-quMoney;
        nowMoney=nowMoney+quMoney;
        System.out.println(account.name+"的余额为"+account.money);
        System.out.println(Thread.currentThread().getName()+"取了"+quMoney+"现在有了"+nowMoney);
    }
}

线程不安全案例三

package com.duoXianCheng.syn;

import java.util.ArrayList;
import java.util.List;

/*
    线程不安全
    	导致线程丢失
 */
public class UnsafeList {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->strings.add(Thread.currentThread().getName())).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(strings.size());
    }
}

同步方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-duqWfast-1613899142590)(D:\date img\QQ截图20210220143905.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yfT6qmlt-1613899142591)(D:\date img\QQ截图20210220151629.png)]

package com.duoXianCheng.syn;
/*
    模拟不安全的买票
        会出现线程不安全的问题，出现负数票
 */
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"1").start();
        new Thread(buyTicket,"2").start();
        new Thread(buyTicket,"3").start();
    }
}
class BuyTicket implements Runnable{
    //需要定义有几张票
    private int ticket=10;
    //使用外部停止
     boolean flg=true;
    @Override
    public void run() {
        while (flg){

            try {
                buy();
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    private synchronized void buy()  {//synchronized

        if (ticket<=0){
            flg=false;
            return;
        }

        System.out.println(Thread.currentThread().getName()+"抢到了第"+ticket--+"张票");
    }
    //

}

package com.duoXianCheng.syn;
/*
    模拟银行取钱

 */
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account("account", 300);
        new Thread(new Bank(account,200,"you "),"you").start();
        new Thread(new Bank(account,300,"girlfriends "),"girlfriends").start();
    }
}
//账户
class Account{
   String name;
   int money;

    public Account(String name, int money) {
        this.name = name;
        this.money = money;
    }
}
//bank
class  Bank extends Thread{
    Account account;
    private int quMoney;
    private int nowMoney;

    public Bank(Account account, int quMoney, String name) {
        super(name);
        this.account = account;
        this.quMoney = quMoney;


    }

    @Override
    public  void run() {
        synchronized (account){//同步监视器 监视的对象是需要增删改查的对象
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (account.money<quMoney){
                System.out.println(Thread.currentThread().getName()+"账户余额不足");
                return;
            }
            account.money=account.money-quMoney;
            nowMoney=nowMoney+quMoney;
            System.out.println(account.name+"的余额为"+account.money);
            System.out.println(Thread.currentThread().getName()+"取了"+quMoney+"现在有了"+nowMoney);
        }
        }

}

package com.duoXianCheng.syn;

import java.util.ArrayList;
import java.util.List;

/*
    线程不安全
 */
public class UnsafeList {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            synchronized (strings){//线程不安全的解决方法  监视的对象是需要增删改查的对象
                new Thread(()->strings.add(Thread.currentThread().getName())).start();
            }

        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(strings.size());
    }
}

JUC安全类的集合

package com.duoXianCheng.syn;

import java.util.concurrent.CopyOnWriteArrayList;

/*
    测试JUC安全类型的集合
 */
public class TextJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 1000; i++) {
            new Thread(()->list.add(Thread.currentThread().getName())).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

死锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d141Wc3F-1613899142592)(D:\date img\QQ截图20210220153850.png)]

package com.duoXianCheng.syn;
/*
    测试死锁
 */
public class DeadLock {
    public static void main(String[] args) {
        Gir gir0 = new Gir("白雪公主", 0);
        Gir gir1 = new Gir("女巫", 1);
        new Thread(gir0).start();
        new Thread(gir1).start();
    }
}
class JinZi{

}
class KouKong{

}
class Gir extends Thread{
    static JinZi jinZi=new JinZi();//static是保证只有一个资源
    static KouKong kouKong=new KouKong();
    String name;
    int choice;
    Gir(String name,int choice){
        this.name=name;
        this.choice=choice;
    }

    @Override
    public void run() {
        try {
            huaZ();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void huaZ() throws InterruptedException {
        if (choice==0){
            synchronized (jinZi){
                System.out.println(this.name+"拿到了镜子");
                Thread.sleep(1000);

            }
            synchronized (kouKong){
                System.out.println(this.name+"拿到了口红");//不能同时拿两把锁，否则就会发生锁死
            }
        }else {
            synchronized (kouKong){
                System.out.println(this.name+"拿到了口红");
                Thread.sleep(3000);

            }
            synchronized (jinZi){
                System.out.println(this.name+"拿到了镜子");
            }
        }
    }
}

Lock(锁)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tBmtTlsg-1613899142593)(D:\date img\QQ截图20210220161631.png)]

package com.duoXianCheng.syn;

import java.util.concurrent.locks.ReentrantLock;

import static java.lang.Thread.sleep;

/*
    测试lock锁
 */
public class TextLock {
    public static void main(String[] args) {
        BuyP buyP = new BuyP();
        new Thread(buyP,"我").start();
        new Thread(buyP,"你").start();
        new Thread(buyP,"他").start();
    }
}
class BuyP implements Runnable{
    ReentrantLock lock=new ReentrantLock();
   boolean flg=true;
    private int p=10;

    @Override
    public void run() {
        try {
            buy();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void buy() throws InterruptedException {
        try{
            lock.lock();//枷锁
            while (flg){
                Thread.sleep(1000);
                if (p<=0){
                    flg=false;
                }
                System.out.println(Thread.currentThread().getName()+"抢到了第"+p--+"张票");

            }
        }finally {
            lock.unlock();//解锁
        }

    }
}

ReentrantLock可重用锁

线程协作

生产者消费者模式(问题)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w8l0nTJp-1613899142594)(D:\date img\QQ截图20210220170413.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vlZVwJdi-1613899142594)(D:\date img\QQ截图20210220170810.png)]

管程法

package com.duoXianCheng.syn;

import java.util.ArrayList;

/*
    测试生产者消费者问题 ————》管程法
        当生产者生产了一只鸡的时候，就通知消费者来吃 ，等待消费者吃
        当消费吃完之后，通知生产者生产，等待生产者生产鸡
 */
public class TextPC {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
        Producer producer = new Producer(synContainer);
        Consumer consumer = new Consumer(synContainer);
        producer.start();
        consumer.start();
    }
}
//生产者
class Producer extends Thread{
    SynContainer container;
    public Producer(SynContainer container){
        this.container=container;
    }

    @Override
    public void run() {
        for (int i = 1; i < 10; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");

        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer container;
    public Consumer(SynContainer container){
        this.container=container;
    }

    @Override
    public void run() {
        for (int i = 1; i < 10; i++) {
            System.out.println("吃了"+container.pop().chickenId+"只鸡");

        }
    }
}
//产品
class Chicken{
    int chickenId;
    Chicken(int chickenId){
        this.chickenId=chickenId;
    }
}
//缓冲区（仓库）
class SynContainer{
    //需要一个容器存放鸡
    Chicken[] chickens=new Chicken[1];
    //需要一个计算器，来看容器里面是否有鸡
     int count=0;

    //生产者生产鸡
    public synchronized void push(Chicken chicken){
        if (count==chickens.length){
            //等待生产者生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        chickens[count]=chicken;

        count++;
        this.notify();
    }
    //消费者消费鸡
    public synchronized Chicken pop(){
        if (count==0){
            //通知生产者
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        count--;
        Chicken chicken=chickens[count];
        this.notify();
        return chicken;

    }
}

信号灯

package com.duoXianCheng.syn;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

/*
    测试生产者消费者为题————》信号灯法
 */
public class TextPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}
//player
class Player extends Thread{
 TV tv;
 public Player(TV tv){
     this.tv=tv;
 }

    @Override
    public void run() {
        for (int i = 1; i < 10; i++) {
            if (i%5==0){
                this.tv.play("广告");
            }else {
                this.tv.play("爱情公寓");
            }


        }
    }
}
//watcher
class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv=tv;
    }

    @Override
    public void run() {
        for (int i = 1; i < 10; i++) {
            tv.watch();
        }
    }
}
//产品
class TV{
    //演员表演时，观众等待，表演完成时通知观众观看
    //观众观看时，演员等待，观看完成时通知演员表演
    boolean flg=true;//创建一个标志
    String name;

//表演方法
    public synchronized void play(String name){
        if (!flg){
            try {
                this.wait();//判断标志为假的时候就等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("表演了节目"+name);
        this.notifyAll();
        this.name=name;
        this.flg=!this.flg;



    }
    //观看方法
    public synchronized void watch(){
        if (flg){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("观看了"+name);
        this.notifyAll();
        this.flg=!this.flg;

    }

}

线程池

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-91soDGaB-1613899142595)(D:\date img\QQ截图20210220220549.png)]

package com.duoXianCheng.syn;



import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
    线程池
 */
public class TextPool {
    public static void main(String[] args) {
        //创建服务，创建线程池
        //newFixedThreadPool：参数为线程池的大小
        ExecutorService service= Executors.newFixedThreadPool(10);
        //执行
        service.execute(new A());
        service.execute(new A());
        service.execute(new A());
        service.execute(new A());//没有返回值
        service.submit(new A());//有返回值的
        //关闭连接
        service.shutdown();

    }
}
class A implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
yuanlcj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
cgb2106-day16
cgblpx的博客
08-15 4891
标题
DAY16
03-28
在Java编程语言的学习过程中，"DAY16"可能代表着一个重要的教学日或者学习阶段，它可能涵盖了关于Java的深入主题或特定技术。由于没有具体的描述，我们可以从一般的Java学习路径来推测可能涵盖的知识点。 在Java的...
day16反射
喝醉酒的小白
07-28 4182
01 反射机制概述 02 常用类
day16-20
li13051517725的博客
03-14 3228
day16: ① 收尾demo项目的学习 解决程序运行过程中的报错； 解决场景切换产生的状态未恢复问题； 加入音效； 调试addEvent的方式监听鼠标点击事件，对比getMouse在屏幕上触点区别，结论是点位置是一样，但通过空button来实现的方式要注意射线遮挡问题； 根据屏幕和电脑点击分析区别，并修正坐标偏移，得到正确可操作坐标； 收尾demo见附件； ② 打猎项目代码初始环境 阅读打猎项目文档，大概了解程式相关设计； ..
cgb2104-day16
cgblpx的博客
06-18 5406
## 一，MVC项目 ### --1，项目结构图 ### --2，
挑战30天学完Python：Day16 日期时间
测试开发转型之旅上的小学生
02-21 2075
🎉 本系列为Python基础学习，原稿来源于英文项目，大奇主要是对其本地化翻译、逐条验证和补充，想通过30天完成正儿八经的系统化实践。此系列适合零基础同学，或仅了解Python一点知识，但又没有系统学习的使用者。总之如果你想提升自己的Python技能，欢迎加入《挑战30天学完Python》
代码随想录训练营day16
weixin_45977348的博客
10-06 2386
代码随想录训练营一期
蓝桥杯31天冲刺打卡题解（Day16）
How many ten years in the life time?
03-23 2498
Day16 第一题 NOIP2015普及组 金币 模拟 数据量比较小，直接双重循环暴力即可。 import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int n = sc.nextInt(); int sum = 0, day = 0; for (int i = 1; i <= n; i++) { for (int
Day16-声明式事务控制
Youmonster的博客
04-01 1522
Day16-声明式事务控制 1. 编程式事务控制相关对象 1.1 PlatformTransactionMananger PlatformTransactionMananger接口是spring的事务管理器，它里面提供了我们常用的操作事务的方法 方法 说明 TrasactionStatus getTransaction(TransactionDefination defination) 获取事务的状态信息 void commit（TrasactionStatus status) 提交事务
CGBTN2109-DAY16总结复习
程序媛泡泡的博客
10-26 1600
Day16复习 1. 回答问题： 1. 什么是进程？什么是程序？有什么区别？ 程序：数据与指令的集合，程序是静态的 进程：给程序加入了时间的概念，不同的时间进程有不同的状态 进程是动态的，就代表OS中正在运行的程序 独立性，动态性，并发性 2. 什么是并行？什么是串行？什么是并发？ CPU:电脑的核心处理器，类似于“大脑” 串行：是指同一时刻一个CPU只能处理一件事，类似于单车道 并行：相对来说资源比较充足，多个CPU可以同时处理不同的多件事，类似于多车道 并发：相对来说资源比较紧缺，多个进程同时抢占公共资
【springboot】springboot学习笔记day16
guaishounan的博客
10-13 3073
springboot学习笔记day16.xmind
Day16-30_Day16-30_python_
10-03
在Python学习之旅中，"Day16-30"阶段是一个关键的过渡期，涵盖了从基础知识到更高级概念的深入探索。在这个阶段，初学者会接触到许多重要的编程概念和技术，这些将为后续的学习打下坚实的基础。以下是这个阶段可能会...
day16.rar
04-20
很抱歉，但根据您提供的信息，"day16.rar"是一个压缩文件，而没有提供具体的描述或标签来指示其中包含的IT知识点。压缩文件通常用于集合多个文件或文件夹，以便于存储、传输或归档。然而，没有额外的上下文，我无法...
day16
06-02
day16javaday16java
学习JavaEE的day16
03-02
在“学习JavaEE的day16”这个主题中，我们主要关注的是Java企业级开发的进一步深入学习。JavaEE（Java Platform, Enterprise Edition）是Java技术在企业应用开发中的核心框架，它为构建分布式、多层的企业级应用程序...
毕业设计，基于SpringBoot+Vue+MySQL开发的音乐网站，源码+数据库+论文答辩+毕业论文+视频演示
08-20
毕业设计，基于SpringBoot+Vue+MySQL开发的音乐网站，源码+数据库+论文答辩+毕业论文+视频演示 随着信息技术在管理上越来越深入而广泛的应用，管理信息系统的实施在技术上已逐步成熟。本文介绍了音乐网站的开发全过程。通过分析音乐网站管理的不足，创建了一个计算机管理音乐网站的方案。文章介绍了音乐网站的系统分析部分，包括可行性分析等，系统设计部分主要介绍了系统功能设计和数据库设计。 本音乐网站管理员功能有个人中心，用户管理，歌曲分类管理，歌曲信息管理，管理员管理，系统管理等。用户可以注册登录，试听歌曲，可以下载歌曲。因而具有一定的实用性。 本站是一个B/S模式系统，采用Spring Boot框架，MySQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得音乐网站管理工作系统化、规范化。本系统的使用使管理人员从繁重的工作中解脱出来，实现无纸化办公，能够有效的提高音乐网站管理效率。 关键词：音乐网站；Spring Boot框架；MySQL数据库
大学生创业计划书(25)-两份资料.doc
08-20
大学生创业计划书(25)-两份资料.doc
基于YOLO-lite的web实时人脸检测，tfjs人脸检测，目标检测+源代码+文档说明+数据集（高分作品）
08-20
<项目介绍> - 基于YOLO-lite的web实时人脸检测，tfjs人脸检测，目标检测 - 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 --------
8051Proteus仿真c源码I2C
最新发布
08-20
8051Proteus仿真c源码I2C提取方式是百度网盘分享地址
#!/usr/bin/env python """Django's command-line utility for administrative tasks.""" import os import sys def main(): """Run administrative tasks.""" os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'day16.settings') try: from django.core.management import execute_from_command_line except ImportError as exc: raise ImportError( "Couldn't import Django. Are you sure it's installed and " "available on your PYTHONPATH environment variable? Did you " "forget to activate a virtual environment?" ) from exc execute_from_command_line(sys.argv) if __name__ == '__main__': main()
07-25
感谢提供 manage.py 文件的内容。根据你的 manage.py 文件，应该没有对 Django 默认命令参数进行修改或添加不正确的参数。 请确保以下几点： 1. 确保你已经在命令行中进入了包含 manage.py 文件的项目根目录。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值