P576线程P582多线程P583startP584Runnable创建线程P58子线程应用P587退出P588方法P591守护线程P592线程7大状态P593同步P594互斥锁P596释放锁P598

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量489 收藏
点赞数
分类专栏： 韩顺平java基础学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kuimeiyuzu/article/details/122808828
版权

576线程-P598作业2

P576线程

P582多线程机制

public class Thread01 {
    public static void main(String[] args) {
        //创建Cat 对象，可以当做线程使用
        Cat cat = new Cat();
        cat.start();//启动线程
        //输出
        //喵喵我猫咪1线程名=Thread-0
        //喵喵我猫咪2线程名=Thread-0
       // 喵喵我猫咪3线程名=Thread-0
        //说明: 当main 线程启动一个子线程Thread-0, 主线程不会阻塞, 会继续执行
        // 这时主线程和子线程是交替执行..
    }
}
老韩说明
1. 当一个类继承了Thread 类， 该类就可以当做线程使用
2. 我们会重写run 方法，写上自己的业务代码
3. run Thread 类实现了Runnable 接口的run 方法
/*
@Override
public void run() {
if (target != null) {
target.run();
}
}
*/
class Cat extends Thread{//演示通过继承Thread 类创建线程
    @Override
    public void run() {
        int count=0;
​
       while(true){
           //重写run方法，写上自己的业务
           System.out.println("喵喵我猫咪"+(++count)+"线程名="+Thread.currentThread().getName());
           让该线程休眠1 秒ctrl+alt+t
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           if(count==3){
               break;//此时线程直接退出
           }
       }
    }
}
public class Thread01  {
    public static void main(String[] args) throws InterruptedException {
        //创建Cat 对象，可以当做线程使用
        Cat cat = new Cat();
        cat.start();//启动线程
        //说明: 当main 线程启动一个子线程Thread-0, 主线程不会阻塞, 会继续执行
        // 这时主线程和子线程是交替执行..
        System.out.println("主程序执行"+Thread.currentThread().getName());
        for (int i = 0; i < 88; i++) {
            System.out.println("主程序i="+i);
            Thread.sleep(1000);
        }
        //输出主程序执行main//主程序i=0//喵喵我猫咪1线程名=Thread-0//主程序i=1
        //喵喵我猫咪84线程名=Thread-0//喵喵我猫咪85线程名=Thread-0//主程序i=84//主程序i=85
        // 喵喵我猫咪86线程名=Thread-0
       //在terminal终端加入JConsole,然后连接-到内存，看到main和thread-01
        //注意，因为主88，thread-01有111，所以main结束而thread01没有，
        // 一直在thread01后，此时不能在连接，已经结束了
        //总结，main线程结束，而子线程不一定结束，所以不会造成整个进行的结束
    }
}
//省略了cat类
P583java为什么是start

public class Thread01  {
    public static void main(String[] args) throws InterruptedException {
        //创建Cat 对象，可以当做线程使用
        Cat cat = new Cat();
        //cat.start();//启动线程-最终会执行线程的Cat的run方法
        cat.run();//run 方法就是一个普通的方法, 没有真正的启动一个线程，就会阻塞在这里，就会把run 方法执行完毕，才向下执行
       //输出为 喵喵我猫咪1线程名=main//喵喵我猫咪2线程名=main//喵喵我猫咪8线程名=main
        //主程序执行main//主程序i=0//主程序i=1
        System.out.println("主程序执行"+Thread.currentThread().getName());
        for (int i = 0; i <5; i++) {
            System.out.println("主程序i="+i);
            Thread.sleep(1000);
        }
    }
}
​
class Cat extends Thread{//演示通过继承Thread 类创建线程
    @Override
    public void run() {
        int count=0;
​
       while(true){
           //重写run方法，写上自己的业务
           System.out.println("喵喵我猫咪"+(++count)+"线程名="+Thread.currentThread().getName());
           让该线程休眠1 秒ctrl+alt+t
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           if(count==8){
               break;//此时线程直接退出
           }
       }
    }
}
cat.start();
//源码
/*
(1)
public synchronized void start() {
        start0();
}
(2)
//start0() 是本地方法，是JVM 调用, 底层是c/c++实现
//真正实现多线程的效果， 是start0(), 而不是run
private native void start0();
(3)
​
 */

P584java_Runnable创建线程

class Animal{};
class Tigger extends Animal implements Runnable{
​
    @Override
    public void run() {
        System.out.println("狮吼");
    }
}
class ThreadProxy implements Runnable{
    private Runnable target=null;//线程代理类, 模拟了一个极简的Thread 类
​
    public ThreadProxy(Runnable target) {
        this.target = target;
    }
​
    @Override
    public void run() {
        if(target != null){
            target.run();//动态绑
        }
    }
    public void start(){
        start0();
    }
    public void start0(){
        run();
    }
}
//Main方法写入
/*
Tigger tigger = new Tigger();//实现了Runabble
        ThreadProxy threadProxy = new ThreadProxy(tigger);
        threadProxy.start();//输出狮吼
*/
public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //这里不能使用Star方法
        //创建了Thread 对象，把dog 对象(实现Runnable),放入Thread
        Thread thread = new Thread(dog);
        thread.start();
    }
}
class Dog implements Runnable{//通过实现Runable接口，开发线程
    int count=0;
​
    @Override
    public void run() {
        while (true){
            System.out.println("小狗"+(++count)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==10){
                break;
            }
        }
    }
}

P585java多个子线程的应用

1秒输出hw 10，另一个Proces输出hi 5

/**
 *main线程启动两个子线程
 */
public class Thead03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();
        thread2.start();
        //输出helloworld1Thread-0//hi1Thread-1//hi2Thread-1
        //helloworld2Thread-0//helloworld3Thread-0
    }
}
class T1 implements Runnable{
    int count=0;
​
    @Override
    public void run() {
        while (true){
            System.out.println("helloworld"+(++count)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==100){
                break;
            }
        }
​
    }
}
class T2 implements Runnable{
    int count=0;
​
    @Override
    public void run() {
        while (true){
            System.out.println("hi"+(++count)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count==66){
                break;
            }
        }
​
    }
}

/**
 * 使用多线程模拟三个窗口同时售票
 */
public class Tick01 {
    public static void main(String[] args) {
        //模拟
        SellTicket01 s1= new SellTicket01();
        SellTicket01 s2= new SellTicket01();
        SellTicket01 s3= new SellTicket01();
        s1.start();
        s2.start();
        s3.start();
        //输出窗口Thread-1售出1张票 剩余1//窗口Thread-2售出1张票 剩余0//售票结束
        // 窗口Thread-0售出1张票 剩余1//售票结束//售票结束
        //出现票数的超卖,因为s1还未完成--，s2已经判断
    }
}
class SellTicket01 extends Thread{
    private static int ticketnum=100;//让多个线程共享
    @Override
    public void run() {
      while (true){
          if(ticketnum<=0){
              System.out.println("售票结束");
              break;
          }
          try {
              Thread.sleep(50);//模拟休息
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println("窗口"+Thread.currentThread().getName()+"售出1张票"+" 剩余"+(--ticketnum));
      }
    }
}
/**
 * 使用多线程模拟三个窗口同时售票
 */
public class Tick01 {
    public static void main(String[] args) {
        SallTicket02 sallTicket02 = new SallTicket02();
         new Thread(sallTicket02).start();//第1个线程
         new Thread(sallTicket02).start();//第2个线程
        new Thread(sallTicket02).start();//第3个线程
        //输出窗口Thread-0售出1张票 剩余0//窗口Thread-2售出1张票 剩余-1
        //售票结束//售票结束//窗口Thread-1售出1张票 剩余-2//售票结束
    }
}
class SellTicket01 extends Thread{
    private static int ticketnum=100;//让多个线程共享
    @Override
    public void run() {
      while (true){
          if(ticketnum<=0){
              System.out.println("售票结束");
              break;
          }
          try {
              Thread.sleep(1000);//模拟休息
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println("窗口"+Thread.currentThread().getName()+"售出1张票"+" 剩余"+(--ticketnum));
      }
    }
}
class SallTicket02 implements Runnable{
    private  int ticketnum=100;//让多个线程共享
    @Override
    public void run() {
        while (true){
            if(ticketnum<=0){
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(50);//模拟休息
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口"+Thread.currentThread().getName()+"售出1张票"+" 剩余"+(--ticketnum));
        }
    }
}

P587通知线程退出

public class ThreadExit {
    public static void main(String[] args) {
        T t = new T();
        t.start();
        System.out.println("主线程休息10s");
        try {
            Thread.sleep(10*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.setLoop(false);//运用方法
    }
}
class T extends Thread{
    int count=0;
    private boolean loop=true;
​
    public boolean isLoop() {
        return loop;
    }
​
    public void setLoop(boolean loop) {
        this.loop = loop;
    }
​
    @Override
    public void run() {
        while (loop){
            try {
                Thread.sleep(50);//模拟休息
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T运行中"+(++count)+Thread.currentThread().getName());
        }
    }
}

P588线程的常用方法

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.setName("ay");
        t.setPriority(Thread.MIN_PRIORITY);
        System.out.println(t.getName());
        t.start();//启动子线程
        //主线程打印5hi,然后我就中断子线程的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi"+i);
        }
       t.interrupt();
        //输出ay,从ay0吃包子到// ay吃包子99
        //ay中休眠//hi0//hi1//hi2//hi3//hi4//ay被interrupt//ay吃包子0
        //如果没有t.interrupt，会ay吃包子99//ay中休眠//hi0//hi1//hi2//hi3//hi4
        // ay吃包子0//ay吃包子1
​
    }
}
class T extends Thread{
    int count=0;
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                System.out.println( Thread.currentThread().getName() +"吃包子" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName()+"中休眠"  );
                Thread.sleep(5000);//模拟休息
            } catch (InterruptedException e) {
                //捕获到一个中断异常
                System.out.println( Thread.currentThread().getName()+"被interrupt" );
            }
​
        }
    }
}

P589线程常用方法

cup 在t1中执行t2的join，需要执行完t2再执行t1

public class Method02 {
    public static void main(String[] args) {
        T2 t2 = new T2();
        t2.start();
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(1000);
                System.out.println("主线程吃了"+i);
                if(i==5){
                    System.out.println("让子线程先吃");
                    t2.join();//插队，让t2完毕
                    System.out.println("主线程接着吃");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
​
    }
}
class T2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程吃包子--"+i);
        }
​
    }
}
P590练习

public class MethodExcercise {
    public static void main(String[] args) {
        Thread thread = new Thread(new N());
        for (int i = 1; i <=10 ; i++) {
            System.out.println("hi"+i);
            try {
                Thread.sleep(1000);
                if(i==5){
                    thread.start();
                    thread.join();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("主线程结束");
    }
}
class N implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i<= 10; i++) {
            System.out.println("hello"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("子线程结束");
    }
}

P591java守护线程

public class Method03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread md = new MyDaemonThread();
        Thread thread = new Thread(md);
        thread.setDaemon(true);
        thread.start();
        //如果我们希望当main线程结束后，子线程自动结束
        //只需要将子线程设为守护现成即可
        for (int i = 1; i <=10; i++) {
            System.out.println("yy辛苦工作");
            Thread.sleep(1000);
        }
    }
}
class MyDaemonThread implements Runnable{
    @Override
    public void run() {
        for (; ; ) {//无限循环
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("mm和m聊天");
        }
    }
}

P592java线程7大状态

new -NEW -start()-被线程调度器执行进入Runnable(两个状态)

Runnable(

Ready (线程被挂起<-----/线程被调度器中选中执行---->/<-----Thread.yeild) Running)

R//—Thread.sleep(time)/o.wait(time)/t.join(time)/LockSupport.parkNanos()/LockSupport.parkUnitil()----->----TimedWaiting-----时间结束----//R

R//——-o.wait()/t.join()/LockSupport.park()---->------ Waiting---->--o.notify()/o.notifyAll()/LockSupport.unpark()------>//R

R//-----等待进入同步代码块的锁-->---Blocked------获得锁----->//R

Teminated

public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName()+"状态"+t.getState());
        t.start();
        while (Thread.State.TERMINATED != t.getState()){
            System.out.println(t.getName()+"状态"+t.getState());
            Thread.sleep(500);
        }
        System.out.println(t.getName()+"状态"+t.getState());
        //输出Thread-0状态NEW//Thread-0状态RUNNABLE
        //hi0//Thread-0状态TIMED_WAITING//Thread-0状态TIMED_WAITING
        //hi3//Thread-0状态RUNNABLE//Thread-0状态TIMED_WAITING
        //hi9//Thread-0状态TIMED_WAITING//Thread-0状态TIMED_WAITING
        //Thread-0状态TERMINATED
    }
}
class T extends Thread{
    private int count=0;
    @Override
    public void run() {
        while (true){
            for (int i = 0; i < 10; i++) {
                System.out.println("hi"+i);
                try {
                    Thread.sleep(1000);//模拟休息
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

P593线程同步

/**
 * 使用多线程模拟三个窗口同时售票
 */
public class Tick01 {
    public static void main(String[] args) {
        SallTicket03 s1 = new SallTicket03();
        new Thread(s1).start();//第1个窗口
        new Thread(s1).start();//第2个窗口
        new Thread(s1).start();//第3个窗口
        //输出//窗口Thread-2售出1张票 剩余2//窗口Thread-1售出1张票 剩余1
        // 窗口Thread-0售出1张票 剩余0//售票结束//售票结束//售票结束
    }
}
//实现接口方法，使用synchronized实现线程
class SallTicket03 implements Runnable{
    private  int ticketnum=100;//让多个线程共享
    private boolean loop=true;
    public synchronized void sell(){
        //同步方法，在同一时刻，只能有一个线程执行run方法
        if(ticketnum<=0){
            System.out.println("售票结束");
            loop=false;
            return;
        }
        try {
            Thread.sleep(700);//模拟休息
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口"+Thread.currentThread().getName()+"售出1张票"+" 剩余"+(--ticketnum));
    }
    @Override
    public  void run() {//同步方法
​
        while (loop){
            sell();
        }
​
    }
}

P594java互斥锁

public class Tick01 {
    public static void main(String[] args) {
        SallTicket03 s1 = new SallTicket03();
        new Thread(s1).start();//第1个窗口
        new Thread(s1).start();//第2个窗口
        new Thread(s1).start();//第3个窗口
        //输出//窗口Thread-2售出1张票 剩余2//窗口Thread-1售出1张票 剩余1
        // 窗口Thread-0售出1张票 剩余0//售票结束//售票结束//售票结束
    }
}
class SallTicket03 implements Runnable{
    private  int ticketnum=100;//让多个线程共享
    private boolean loop=true;
    //老韩说明
//1. public synchronized void sell() {} 就是一个同步方法
//2. 这时锁在this 对象
//3. 也可以在代码块上写synchronize ,同步代码块, 互斥锁还是在this 对象
    public /*synchronized*/void sell() {
        synchronized (this) {//代码块
            if (ticketnum <= 0) {
                System.out.println("售票结束");
                loop = false;
                return;
            }
            try {
                Thread.sleep(70);//模拟休息
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口" + Thread.currentThread().getName() + "售出1张票" + " 剩余" + (--ticketnum));
        }
    }
    @Override
    public  void run() {//同步方法
​
        while (loop){
            sell();
        }
​
    }
}
//修改部分
class SallTicket03 implements Runnable{
    private  int ticketnum=100;//让多个线程共享
    private boolean loop=true;
    Object object=new Object();//因为对象是相同的，所以object也是相同的
    //老韩说明
//1. public synchronized void sell() {} 就是一个同步方法
//2. 这时锁在this 对象
//3. 也可以在代码块上写synchronize ,同步代码块, 互斥锁还是在this 对象
    public /*synchronized*/void sell() {
        synchronized (/*this*/object) {//代码块
class SallTicket03 implements Runnable{
    private  int ticketnum=100;//让多个线程共享
    private boolean loop=true;
    Object object=new Object();
    //同步方法（静态的）的锁为当前类本身//老韩解读
//1. public synchronized static void m1() {} 锁是加在SellTicket03.class
    public synchronized static void m1(){}
    //2. 如果在静态方法中，实现一个同步代码块.
    /*
    public synchronized static void m2(){
        synchronized (SallTicket03.class){
            System.out.println("m2");
        }
    }
     */

P595线程死锁

public class DeadLock {
    public static void main(String[] args) {
        DD A = new DD(true);
        A.setName("A线程");
        DD B = new DD(false);
        B.setName("B线程");
        A.start();
        B.start();
        //B线程Jinru3
        //A线程Jinru1
    }
}
class DD extends Thread{
    static Object o1=new Object();
    static Object o2=new Object();
    boolean flag;
​
    public DD(boolean flag) {
        this.flag = flag;
    }
//如果flag真，则线程持有o1对象锁/持有后尝试获取o2，如果得不到就会Blocked
    //如果flag假，则线程持有o2对象锁/持有后尝试获取o1，如果得不到就会Blocked
    //如果A真，B为假，死锁了
    @Override
    public void run() {
        if(flag){
            synchronized (o1){//对象互斥锁，下面就是同步代码
                System.out.println(Thread.currentThread().getName()+"Jinru1");
                synchronized (o2){//如果拿不到o2
                    System.out.println(Thread.currentThread().getName()+"Jinru2");
                }
            }
        }else {
            synchronized (o2){
                System.out.println(Thread.currentThread().getName()+"Jinru3");
                synchronized (o1){
                    System.out.println(Thread.currentThread().getName()+"Jinru4");
                }
            }
        }
    }
}

P596释放锁

 

P597线程家庭作业

两个线程，B控制A，则B里面有进程A对象

import java.util.Scanner;
​
public class Homework01 {
    public static void main(String[] args) {
        A a = new A();
        B b = new B(a);
        a.start();
        b.start();
        //输出输入Q退出：
        //41//26//19//10//Q
    }
}
class A extends Thread{
    private boolean loop=true;
​
    public void setLoop(boolean loop) {
        this.loop = loop;
    }
    @Override
    public void run() {
        while (loop){
            System.out.println((int)(Math.random() * 100+1));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class B extends Thread{
    private A a;
    private Scanner scanner=new Scanner(System.in);
​
    public B(A a) {
        this.a = a;
    }
​
    @Override
    public void run() {//直接传入A类对象
        //接收到用户输入
​
        while (true){
            System.out.println("输入Q退出：");
            char key = scanner.next().toUpperCase().charAt(0);
            if(key=='Q'){
               //以通知的方式结束
                a.setLoop(false);
                break;
            }
        }
    }
}
P598作业2

public class Homework02 {
    public static void main(String[] args) {
        Car car = new Car();
        Thread thread1 = new Thread(car);
        Thread thread2 = new Thread(car);
        thread1.setName("A进程");
        thread2.setName("B进程");
        thread1.start();
        thread2.start();
    }
}
class Car implements Runnable{
    private int money=10000;
    @Override
    public  void run() {
       while (true){
           synchronized (this){
               if(money<1000){
                   System.out.println(Thread.currentThread().getName()+"不能取");
                   break;
               }
               money -= (int) (Math.random() * 1000 + 1);
               System.out.println(Thread.currentThread().getName() + "取钱了，现剩余" + money);
               try {
                   Thread.sleep(100);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
    }
}

「已注销」
关注
专栏目录
每天一个ebpf工具 io篇(一) ----------- biosnoop
happyAnger6的专栏
05-22 135
这里的延迟是１.1中, 2和3操作之间的延迟。即从内核将i/o操作提交给块设备到块设备完成操作通知内核软中断处理的耗时.linux对每个磁盘或分区都维护有一个请求队列,i/o算法会进行操作的合并重排等操作以优化性能。i/o结束时,分别统计i/o请求在队列中的等待时间和i/o操作块设备的延迟时间.显示进行i/o操作的程序，操作的磁盘扇区，读/写操作, 字节数，以及延迟。获取当前放入i/o request_queue的时间，并放入map中。获取当前提交块设备i/o请求的时间，并放入map中。
576 C
asmallfish1985的博客
07-31 479
C. MP3 爆ll == #include<bits/stdc++.h> using namespace std; typedef long long ll; #define P pair<int,int> #define sc(x) scanf("%I64d",&x); #define maxn 400005 vector<l...
算法设计经典练习六——迷宫问题
weixin_44602007的博客
04-09 4320
迷宫问题（maze problem）—— 深度优先与广度优先搜索求解 ...
七牛云的go语言多线程上传
weixin_42727578的博客
03-06 608
package main import ( "flag" "io/ioutil" "strings" "sync" "time" "fmt" "qiniupkg.com/api.v7/conf" "qiniupkg.com/api.v7/kodo" "qiniupkg.com/api.v7/kodocli"
bootstartp 时间选择组件
zhuixunhebe1的专栏
03-06 1099
http://www.bootcss.com/p/bootstrap-datetimepicker/
bootstartp 简单登陆页面（另成一个html就可以看到效果）
zhuixunhebe1的专栏
03-20 1909
Bootstrap In Practice - Landing Page Example                                 /* http://css-tricks.com/perfect-full-page-background-image/ */         html {             backg
python多线程下载合并_python 多线程将大文件分开下载后在合并的实例
weixin_35158450的博客
12-23 121
废话不多说了，上代码吧：import threadingimport requestsimport timeimport osclass Mythread(threading.Thread):def __init__(self,url,startpos,endpos,f):super(Mythread,self).__init__()self.url=urlself.startpos=startp...
python 多线程下载_python 多线程将大文件分开下载后在合并的实例
weixin_39874366的博客
12-05 80
废话不多说了，上代码吧：import threadingimport requestsimport timeimport osclass Mythread(threading.Thread):def __init__(self,url,startpos,endpos,f):super(Mythread,self).__init__()self.url=urlself.startpos=startp...
Luogu P1126 机器人搬重物
qq_18352005的博客
07-01 389
显然是个广搜。但这道题的毒瘤之处在于，1，每次移动格数不定，2，有转向时间，要考虑到每一格时的朝向，3，题目给的是方格，但机器人是在顶点上移动的。一切从读入数据开始。读入方格图及起终点坐标。点用&lt;utility&gt;里的pair类储存即可，默认构造函数及复制构造函数都写好了，方便使用。然后要做的就是把方格图转换为顶点图。再开一个二维数组，还是用1表示不可达，0表示可达。显而易见，一个点的上...
Java网络编程：Socket实现的扫描程序设计 （完整代码实现）
Viper的程序员修炼手册
11-08 3540
扫描程序设计 目标主机扫描是网络功防的基础和前提，扫描探测一台目标主机包括：确定该目标主机是否活动、目标主机的操作系统、正在使用哪些端口、对外提供了哪些服务、相关服务的软件版本等等，对这些内容的探测就是为了“对症下药”，为攻防提供参考信息。 对主机的探测工具非常多，比如大名鼎鼎的nmap、netcat、superscan，以及国内的x-scanner等等。我们自己动手做简单扫描软件或工具，用于加深对网络编程的理解。 知识点：进一步理解 new Socket()、Process类和ICMP。 一、程序设计第一
【FPGA教程案例38】通信案例8——基于FPGA的串并-并串数据传输
FPGA/MATLAB学习教程/源码/项目合作开发
07-23 2107
并串/串并转换电路在通信接口中具有广泛的应用，可编程逻辑阵列由于具备灵活、可重构等特点非常适应于并串转换硬件电路的实现。并串/串并转换电路作为一种重要的数字信号传输途径，在SPI、I2C、UART等接口协议及高速SERDES、PCIE等通信接口上具有广泛的应用。在FPGA的并串/串并转换电路实现中，采用计数器的方法来实现并串转换电路是应用最多的方法。其实现结构如下图所示如上图所示，对于串并部分，通过一个计数器和移位寄存器，将N个不同时刻的串行数据存入到一个N位位宽的并行数据中。得到如下的仿真结果。...
图论算法＜三＞：Dijkstra算法介绍及用法实例
欧特GO
09-23 1283
Dijkstra算法介绍、流程分析、真实图案例计算最短路径，提供C++源码。
12-3 泛型 ---- 自定义范型结构练习
wp_886的博客
02-19 369
12-3 泛型 ---- 自定义范型结构练习 1.定义个泛型类 DAO，在其中定义一个Map 成员变量，Map 的键为 String 类型，值为 T 类型。 分别创建以下方法： public void save(String id,T entity)： 保存 T 类型的对象到 Map 成员变量中 public T get(String id)：从 map 中获取 id 对应的对象 public void update(String id,T entity)：替换 map 中key为id的内容,改为 enti
迷宫问题（maze problem）—— 深度优先与广度优先搜索求解
热门推荐
Dablelv 的博客专栏。
05-02 6万+
1.问题简介给定一个迷宫，指明起点和终点，找出从起点出发到终点的有效可行路径，就是迷宫问题（maze problem）。迷宫可以以二维数组来存储表示。0表示通路，1表示障碍。注意这里规定移动可以从上、下、左、右四方方向移动。坐标以行和列表示，均从0开始，给定起点（0,0）和终点（4,4），迷宫表示如下：int maze[5][5]={ {0,0,0,0,0}, {0,1,0,1,0}
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1468
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 269
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 321
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 938
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值