线程（并发）

最新推荐文章于 2024-08-11 20:00:32 发布
最新推荐文章于 2024-08-11 20:00:32 发布
阅读量83 收藏
点赞数
文章标签： java
原文链接：https://my.oschina.net/qcAtKmTCeCA/blog/727889
版权
  1. 线程的创建方式 
    class TaskWithResult implements Callable<String>{
    private int id;

    public TaskWithResult(int id) {
        this.id = id;
    }
    @Override
    public String call() throws Exception {
        return "result of taskResult is " +id;
    }
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        List<Future<String>> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            Future<String> future = executorService.submit(new TaskWithResult(i));
            list.add(future);
        }
        try {
            for (Future<String> future : list) {
                if(future.isDone()){
                    System.out.println(future.get());
                }//也可以直接调用get方法，这个时候get会被阻塞，直到task完成之后才被执行 
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
    public class TestRunable implements Runnable{
   protected int countDown = 10;
   private static int taskCount = 0;//当前运行的线程计数
   private final int id = taskCount++;//当前线程id标记
   public String status() {
        return "#" + id + "(" + (countDown > 0 ? countDown : "lifeOff") + ")." + taskCount;
   }
   @Override
   public void run() {
      while (countDown >= 0) {
         System.out.println(status());
         Thread.yield();
         countDown--;
      }
   }
   public static void main(String[] args){
       for(int i=0;i<5;i++) {
           Thread t = new Thread(new LifeOff());
           t.start();
       }
   }
}
    public class TestThread extends Thread{
   protected int countDown = 10;
   private static int taskCount = 0;//当前运行的线程计数
   private final int id = taskCount++;//当前线程id标记
   public String status() {
        return "#" + id + "(" + (countDown > 0 ? countDown : "lifeOff") + ")." + taskCount;
   }
   public void run(){
      while(countDown >= 0){
         System.out.println(status());
         Thread.yield();
         countDown--;
      }
   }
   public static void main(String[] args){
       for(int i=0;i<5;i++){
           Thread a = new TestThread();
           a.start();
       }
   }
}

     

  2. java线程管理（线程包装器Executors） 
    class LifeOff implements Runnable {
    protected int countDown = 10;
    private static int taskCount = 0;
    private final int id = taskCount++;

    public LifeOff() {}

    public LifeOff(int countDown) {
        this.countDown = countDown;
    }

    public String status() {
        return "#" + id + "(" + (countDown > 0 ? countDown : "lifeOff") + ")." + taskCount;
    }

    @Override
    public void run() {
        while (countDown >= 0) {
            System.out.println(status());
            Thread.yield();
            countDown--;
        }
    }
}
public class JunitTest{
   public void static main(String[] args){
       //创建一个最小线程未0，最大为2的31次方-1，存活时间为60s（空闲线程的存活时间）的线程池
       //会创建和所需数量相同的线程（一个任务对应一个线程），在回收线程时（当线程超过最大容量，且闲置时间超过设置的时间时）停止创建线程
       //是相对合理的线程管理对象
       ExecutorService service = Executors.newCachedThreadPool();
       //当newCachedThreadPool可能会发生问题时，应该考虑另一种方式（指定创建的线程数量）
       ExecutorService service = Executors.newFixThreadPool(3);
       //当需要在某一个线程中长期运行某个任务时，你需要使用SingleThreadExecutor,这个是线程数量为1的FixedTheadPool
       //任何时间任何线程都只有一个任务在运行
       ExecutorService service = Executors.newSingleThreadExecutor();
       for(int i=0;i<5;i++){
           service.execute(new LifeOff());
       }
       service.shutdown();
   }
}

     

  3. 优先级（听起来好像很高大上，但是我能说没看懂么，测试貌似没什么卵用） 
    class SimplePriorities implements Runnable {
    private int countDown = 5;
    private int priority;
    private volatile double d;

    public SimplePriorities(int priority) {
        this.priority = priority;
    }

    @Override
    public String toString() {
        return Thread.currentThread() + ":" + countDown;
    }

    @Override
    public void run() {
        Thread.currentThread().setPriority(priority);
        //通过大量浮点运算，来让线程优先级调度介入，从而主动控制线程（貌似没什么效果，应该还是和OS对CPU调度有关）
        while (true) {
            for (int i = 0; i < 100000; i++) {
                d += (Math.PI + Math.E) / (double) i;
                if (i % 1000 == 0) {
                    Thread.yield();
                }
            }
            System.out.println(this);
            if (--countDown == 0) {
                return;
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            executorService.execute(new SimplePriorities(Thread.MIN_PRIORITY));
            executorService.execute(new SimplePriorities(Thread.MAX_PRIORITY));
        }
        executorService.shutdown();
    }
}

     

  4. 后台线程：通过setDaemon(true)可以设置线程未后台运行，且必须在start()调用前设置；且当所有非后台线程结束后（程序终止），后台线程自动结束 
    /**
 * 后台线程
 * 当所有非后台线程结束后，则后台线程自动结束
 * 可以通过修改sleep的时间可以明显看到效果
 */
class SimpleDaemon implements Runnable{
    @Override
    public void run() {
        try {
            //这里写一个死循环，无限执行当前线程的打印
            while (true) {
                System.out.println(Thread.currentThread()+"..."+this);
                TimeUnit.MILLISECONDS.sleep(100);//等同Thread.currentThread().sleep(100)
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        for (int i=0;i<10;i++) {
            Thread thread = new Thread(new SimpleDaemon());
            //设置要执行的线程未后台线程：必须在执行前设置
            thread.setDaemon(true);
            thread.start();
        }
        System.out.println("SimpleDaemon start");
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

    //通过实现ThreadFactory来设置线程的一些属性，比如优先级、名称、是否为后台线程（priority,name,daemon等）
class DaemonThreadFactory implements ThreadFactory{
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setDaemon(true);
        return thread;
    }
}

class DaemonFromFactory implements Runnable {
    @Override
    public void run() {
        try {
            //这里写一个死循环，无限执行当前线程的打印
            while (true) {
                TimeUnit.MILLISECONDS.sleep(100);//等同Thread.currentThread().sleep(100)
                System.out.println(Thread.currentThread()+"..."+this);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        //通过Executors.newCachedThreadPool(ThreadFactory f)来设置线程的属性
        ExecutorService executorService = Executors.newCachedThreadPool(new DaemonThreadFactory());
        for (int i=0;i<10;i++) {
            executorService.execute(new DaemonFromFactory());
        }
        System.out.println("SimpleDaemon start");
        TimeUnit.MILLISECONDS.sleep(200);
        executorService.shutdown();
    }
}

     

  5. 线程协作（wait --- notifyAll） 
    /**
 * synchronized wait -- notifyAll方式
 * car的抛光和打蜡的并发操作
 */
class Car {
    /*打蜡是否OK的标记*/
    private boolean waxOn = false;
    /*已经打好蜡OK了，等待抛光*/
    public synchronized void waxed() {
        waxOn = true;
        notifyAll();
    }
    /*已经抛光OK了，等待打蜡*/
    public synchronized void buffed() {
        waxOn = false;
        notifyAll();
    }
    /*如果未打蜡，则等待打蜡*/
    public synchronized void waitForWax()throws InterruptedException {
        while (waxOn == false) {
            wait();
        }
    }
    /*如果打蜡OK了，则等待抛光*/
    public synchronized void waitForBuffed() throws InterruptedException {
        while (waxOn == true) {
            wait();
        }
    }
}
 
/**
 * 打蜡
 */
class WaxOn implements Runnable {
 
    private Car car;
 
    public WaxOn(Car car) {
        this.car = car;
    }
    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                /*先判断当前车是否打蜡OK，如果OK，则修改打蜡标记，然后等待抛光*/
//                car.waitForWax();
                car.waxed();
                System.out.println("打蜡完成。。。");
                car.waitForBuffed();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
 
/**
 * 抛光
 */
class Buffed implements Runnable {
 
    private Car car;
 
    public Buffed(Car car) {
        this.car = car;
 
    }
    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                /*先判断是否打蜡OK了，如果打蜡OK，则进行抛光，然后等待打蜡*/
                car.waitForWax();
                System.out.println("正在抛光中。。。");
                car.buffed();
//                car.waitForWax();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
 
class CarTest {
 
    public static void main(String[] args) throws InterruptedException{
        Car car = new Car();
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i=0;i<3;i++) {
            executorService.execute(new WaxOn(car));
            executorService.execute(new Buffed(car));
            TimeUnit.MILLISECONDS.sleep(1);
        }
        executorService.shutdownNow();
    }
 
}
    /**
 * lock方式
 * car的抛光和打蜡的并发操作
 */
class Car {
    /*打蜡是否OK的标记*/
    private boolean waxOn = false;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    /*已经打好蜡OK了，等待抛光*/
    public void waxed() {
        lock.lock();
        try {
            waxOn = true;
            condition.signalAll();
        } finally {
            lock.unlock();/*任何情况下都要保证释放锁*/
        }
    }
    /*已经抛光OK了，等待打蜡*/
    public void buffed() {
        lock.lock();
        try {
            waxOn = false;
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }
    /*如果未打蜡，则等待打蜡*/
    public void waitForWax()throws InterruptedException {
        lock.lock();
        try {
            while (waxOn == false) {
                condition.await();
            }
        } finally {
            lock.unlock();
        }
    }
    /*如果打蜡OK了，则等待抛光*/
    public void waitForBuffed() throws InterruptedException {
        lock.lock();
        try {
            while (waxOn == true) {
                condition.await();
            }
        } finally {
            lock.unlock();
        }
    }
}
 
/**
 * 打蜡
 */
class WaxOn implements Runnable {
 
    private Car car;
 
    public WaxOn(Car car) {
        this.car = car;
    }
    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                /*先判断当前车是否打蜡OK，如果OK，则修改打蜡标记，然后等待抛光*/
//                car.waitForWax();
                car.waxed();
                System.out.println("打蜡完成。。。");
                car.waitForBuffed();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
 
/**
 * 抛光
 */
class Buffed implements Runnable {
 
    private Car car;
 
    public Buffed(Car car) {
        this.car = car;
 
    }
    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                /*先判断是否打蜡OK了，如果打蜡OK，则进行抛光，然后等待打蜡*/
                car.waitForWax();
                System.out.println("正在抛光中。。。");
                car.buffed();
//                car.waitForWax();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
 
class CarTest {
 
    public static void main(String[] args) throws InterruptedException{
        Car car = new Car();
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i=0;i<3;i++) {
            executorService.execute(new WaxOn(car));
            executorService.execute(new Buffed(car));
            TimeUnit.MILLISECONDS.sleep(1);
        }
        executorService.shutdownNow();
    }
 
}
    /**
 * linkedBlockingQueue（阻塞队列）方式
 * 生产吐司、给吐司添加黄油、给吐司添加果酱
 * 吐司
 */
class Toast {

    /*状态：dry空白吐司，buttered添加好黄油的，jamed添加好果酱的*/
    public enum Status {
        DRY("有吐司"), BUTTERED("有黄油"), JAMED("有果酱");
        private String name;

        private Status(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }

    private Status status = Status.DRY;
    private int id;

    public Toast(int id) {
        this.id = id;
    }

    /*添加黄油*/
    public void butted() {
        status = Status.BUTTERED;
    }

    /*添加果酱*/
    public void jamed() {
        status = Status.JAMED;
    }

    public Status getStatus() {
        return status;
    }

    public int getId() {
        return this.id;
    }

    @Override
    public String toString() {
        return "Toast " + id + ":" + status.getName();
    }
}

class ToastQueue extends LinkedBlockingQueue<Toast> {
    /*设置该队列的容量*/
    public ToastQueue(int i) {
        super(i);
    }
}

/*生产吐司*/
class Toaster implements Runnable {

    private ToastQueue toastQueue;
    private int count = 0;

    public Toaster(ToastQueue toastQueue) {
        this.toastQueue = toastQueue;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                Toast toast = new Toast(count++);
                System.out.println(toast);
                /*添加到已经生产好toast的队列*/
                toastQueue.put(toast);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/*添加黄油的线程*/
class Buffer implements Runnable {

    private ToastQueue bufferQueue;
    private ToastQueue toastQueue;

    public Buffer(ToastQueue toastQueue, ToastQueue bufferQueue) {
        this.bufferQueue = bufferQueue;
        this.toastQueue = toastQueue;
    }

    private int count = 0;

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                /*取出toast，添加黄油，并存放在已经添加完黄油队列*/
                Toast toast = toastQueue.take();
                toast.butted();
                System.out.println(toast);
                bufferQueue.put(toast);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Jamer implements Runnable {

    private ToastQueue bufferQueue;
    private ToastQueue jamerQueue;

    public Jamer(ToastQueue bufferQueue, ToastQueue jamerQueue) {
        this.bufferQueue = bufferQueue;
        this.jamerQueue = jamerQueue;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                Toast toast = bufferQueue.take();
                toast.jamed();
                System.out.println(toast);
                jamerQueue.put(toast);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("jam finished");
    }
}

class Finisher implements Runnable {

    private ToastQueue jamerQueue;
    private int        count;

    public Finisher(ToastQueue jamerQueue) {
        this.jamerQueue = jamerQueue;
    }

    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                Toast toast = jamerQueue.take();
                if (toast.getId() != count++ || toast.getStatus() != Toast.Status.JAMED) {
                    System.err.println("不是同一块toast，或者没有添加果酱 " + toast);
                    System.exit(1);
                } else {
                    System.out.println(toast);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ToastTest {

    public static void main(String[] args) throws Exception {
        ToastQueue toastQueue = new ToastQueue(1);
        ToastQueue bufferQueue = new ToastQueue(1);
        ToastQueue jamerQueue = new ToastQueue(1);
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new Toaster(toastQueue));
        for (int i = 0; i < 5; i++) {
            executorService.execute(new Buffer(toastQueue, bufferQueue));
            executorService.execute(new Jamer(bufferQueue, jamerQueue));
            executorService.execute(new Finisher(jamerQueue));
        }
        TimeUnit.MILLISECONDS.sleep(50);
        executorService.shutdownNow();
    }

}
    /*
 * 使用管道必须保证输入输出的对象创建完成（如main方法中new2个对象），否则在不同平台会发生不一致问题
 * 理论不建议使用管道来操作线程协作，建议使用BlockQueue更方便，也更安全
 *管道写入端
 * */
class Sender implements Runnable {

    private PipedWriter pipedWriter;

    public Sender(PipedWriter pipedWriter) {
        this.pipedWriter = pipedWriter;
    }
    public PipedWriter getPipedWriter() {
        return pipedWriter;
    }
    @Override
    public void run() {
        try {
            while (true) {
                for (char i = 'A'; i <= 'z'; i++) {
                    pipedWriter.write(i);
                }
                TimeUnit.MILLISECONDS.sleep(100);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException ee) {
            ee.printStackTrace();
        }
    }
}
/*管道接收端*/
class Receiver implements Runnable {

    private PipedReader reader;

    private Sender sender;

    public Receiver(Sender sender) throws Exception{
        reader = new PipedReader(sender.getPipedWriter());
    }
    @Override
    public void run() {
        try {
            while (true) {
                /*使用reader.read()会在线程池调用shutdownNow()时直接截断，无论reader是否有读完*/
                System.out.println("Read "+reader.read() + ",");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class PipedMain {

    public static void main(String[] args) throws Exception{
        PipedWriter pipedWriter = new PipedWriter();
        Sender sender = new Sender(pipedWriter);
        Receiver receiver = new Receiver(sender);
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(sender);
        service.execute(receiver);
        TimeUnit.MILLISECONDS.sleep(100);
        service.shutdownNow();
    }

}

     

  6.  

转载于:https://my.oschina.net/qcAtKmTCeCA/blog/727889

chengshun9686
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 读书笔记 21.4 并发
墨
03-15 240
终结任务相关参考2.2 在任务阻塞时终结sleep()方法将线程由执行状态变为阻塞状态线程状态：新建（new）：当线程被创建时，线程会短暂地处于这种状态。此时，线程已经被分配了必需的系统资源，并执行了初始化。此时线程已经有资格获得CPU的时间，此时只是有能力去争取CPU的时间。之后 ，调度器将把这个线程转变为可就绪或者阻塞状态就绪（Runnable）：在这种状态下，线程调度器只要将时间片分配给线程，
Java多线程并发编程技术详解
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 2万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
多线程并发
qq_40126996的博客
01-18 2639
总结： 多线程并发 (一) 了解 Java 虚拟机 - JVM 学习知道了创建一个线程会触发JVM创建一个私有的虚拟机栈、程序计数器，当前的虚拟机栈内存就是当前线程的运行内存，程序计数器就是记录当前线程运行的代码的地址。 多线程并发 (二) 了解 Thread 学习了线程的运行状态、线程的创建方式、调度原理等。 多线程并发 (三) 锁 synchronized、volatile...
单线程并发
lzc_23的博客
04-29 1993
本文翻译自http://tutorials.jenkov.com/java-concurrency/singlethreaded-concurrency.html，机翻加人工校正，仅供学习交流。 单线程并发 单线程并发意味着从一个线程内似乎同时在多个任务上取得进展。从表面上看，单线程并发听起来有点矛盾。在以前多线程体系结构中，多个任务将被分配到多个线程中，以便并发执行。因此，不同任务之间的切换是通过操作系统和CPU之间的不同切换来完成的。实际上，一个线程可以同时在多个任务上取得进展。在这个单线程并发性教程中
JAVA多线程并发
xunjiu的博客
02-22 1万+
JAVA线程实现/创建方式 1.继承Thread类 Thread类本质上时实现了Runnable接口的一个实例，代表一个现成的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法 public class MyThread extends Thread{ public void run(){ System.out.println("MyTread.r...
python之多线程并发
qishuzdh的博客
07-04 1万+
今天呢笔者想和大家来聊聊python多线程的并发，废话就不多说了咱们直接进入主题哟。 python的内置模块提供了两个内置模块：thread和threading，thread是源生模块，threading是扩展模块，在thread的基础上进行了封装及改进。所以只需要使用threading这个模块就能完成并发的测试实例创建并启动一个单线程 执行结果 其实单线程的执行结果和单独执行某一个或者某一组函数结果是一样的，区别只在于用线程的方式执行函数，而线程是可以同时执行多个的，函数是不可以同时执行的。上面介
python多线程并发测试
ping233的博客
08-08 2657
python之多并发编程
c++ 多线程并发
是鲤鱼啊
02-08 3445
1。
Python多线程并发编程
07-14 5449
运行结果： 二、Python多线程编程 2.1、通过threading实现多线程 运行结果： 2.2、守护线程 运行结果： 2.2、等某个子线程执行完在继续执行主线程（join） 运行结果： 2.4、继承Thread实现多线程 运行结果： 三、线程同步 线程锁机制（Lock） 运行结果：..................
JAVA多线程并发编程汇总
lsp12lsp的博客
10-26 1998
java并发编程汇总
python多线程并发及测试框架案例
09-18
在实际应用中，多线程并发处理常用于I/O密集型任务，如网络请求、文件读写等。然而，由于Python的全局解释器锁（GIL）的存在，多线程在CPU密集型任务上可能无法充分利用多核处理器的优势。因此，对于CPU密集型任务，...
Java多线程并发执行demo代码实例
08-18
"Java多线程并发执行demo代码实例" 在Java编程中，多线程并发执行是非常重要的概念，它可以提高程序的执行效率和响应速度。今天，我们通过一个demo代码实例来学习Java多线程并发执行的实现。 知识点1：泛型 在...
线程并发线程池
01-17
线程并发线程池是计算机科学中的一个重要概念，特别是在多任务处理和服务器应用程序中。它涉及到操作系统如何管理和调度多个线程以实现高效的资源利用。在本项目中，开发者使用了Visual Studio 2008的MFC（Microsoft...
多线程并发处理的简单实现
10-05
在编程领域，多线程并发处理是一种常见的优化技术，它能充分利用多核处理器的资源，提高程序的执行效率。在给定的标题“多线程并发处理的简单实现”中，我们可以深入探讨如何构建这样的系统。 首先，多线程并发处理...
基于Qt的多线程并发服务器
08-03
"基于Qt的多线程并发服务器"是一个典型的解决方案，它利用了Qt库的强大功能，特别是其对多线程的支持，来处理来自多个客户端的并发请求。下面我们将深入探讨这个主题。 首先，Qt是一个跨平台的应用程序开发框架，...
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 325
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
（javaweb）请求响应postman
2301_79144798的博客
08-08 477
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
最新发布
m0_74124657的博客
08-11 264
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 229
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
Netty中多线程并发编程详解及其应用策略
"《多线程并发编程在Netty中的应用分析》是一篇由李林锋撰写的专业论文，主要探讨了在高性能网络框架Netty中如何有效地利用多线程并发技术。论文首先阐述了Java内存模型和多线程编程的重要性，强调了随着硬件发展...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值