Java线程基础知识

最新推荐文章于 2023-10-13 16:54:47 发布
最新推荐文章于 2023-10-13 16:54:47 发布
阅读量116 收藏 1
点赞数 1
分类专栏： Java并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53474063/article/details/111415405
版权

一、线程简介

什么是进程

进程可视为一个正在运行的程序。它是系统运行程序的基本单位，因此进程是动态的。进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动。进程是操作系统进行资源分配的基本单位。

什么是线程

线程是操作系统进行调度的基本单位。线程也叫轻量级进程（Light Weight Process），在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。

进程和线程的区别

  • 一个程序至少有一个进程，一个进程至少有一个线程。
  • 线程比进程划分更细，所以执行开销更小，并发性更高。
  • 进程是一个实体，拥有独立的资源；而同一个进程中的多个线程共享进程的资源。

二、线程的基本方法

方法

描述

run

线程的执行实体。

start

线程的启动方法。

currentThread

返回对当前正在执行的线程对象的引用。

setName

设置线程名称。

getName

获取线程名称。

setPriority

设置线程优先级。Java 中的线程优先级的范围是 [1,10]，一般来说，高优先级的线程在运行时会具有优先权。可以通过 thread.setPriority(Thread.MAX_PRIORITY) 的方式设置，默认优先级为 5。

getPriority

获取线程优先级。

setDaemon

设置线程为守护线程。

isDaemon

判断线程是否为守护线程。

isAlive

判断线程是否启动。

interrupt

中断另一个线程的运行状态。

interrupted

测试当前线程是否已被中断。通过此方法可以清除线程的中断状态。换句话说，如果要连续调用此方法两次，则第二次调用将返回 false（除非当前线程在第一次调用清除其中断状态之后且在第二次调用检查其状态之前再次中断）。

join

可以使一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。

Thread.sleep

静态方法。将当前正在执行的线程休眠。

Thread.yield

静态方法。将当前正在执行的线程暂停，让其他线程执行。

创建线程的方式

创建线程有三种方式：

  • 继承Thread类
  • 实现Runnable接口
  • 实现Callable接口

继承Thread类

通过继承Thread类创建线程的步骤：

① 定义Thread类的子类，并重写该类的run方法。run方法的方法体就代表了线程要完成的任务，因此把run方法称为执行体。

② 创建Thread子类的实例，即创建了线程对象。

③ 调用线程对象的start方法来启动线程。

public class ThreadDemo {

    public static void main(String[] args) {
        // 实例化对象
        MyThread tA = new MyThread("Thread 线程-A");
        MyThread tB = new MyThread("Thread 线程-B");
        // 调用线程主体
        tA.start();
        tB.start();
    }

    static class MyThread extends Thread {

        private int ticket = 5;

        MyThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            while (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + " 卖出了第 " + ticket + " 张票");
                ticket--;
            }
        }

    }
}

实现Runnable接口

实现Runnable接口优于继承Thread类，因为：

  • Java 不支持多重继承，所有的类都只允许继承一个父类，但可以实现多个接口。如果继承了 Thread类就无法继承其它类，这不利于扩展。
  • 类可能只要求可执行就行，继承整个Thread类开销过大。

通过实现Runnable接口创建线程的步骤：

① 定义Runnable接口的实现类，并重写该接口的run方法。该run方法的方法体同样是该线程的线程执行体。

② 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

③ 调用线程对象的start方法来启动该线程。

public class RunnableDemo {

    public static void main(String[] args) {
        // 实例化对象
        Thread tA = new Thread(new MyThread(), "Runnable 线程-A");
        Thread tB = new Thread(new MyThread(), "Runnable 线程-B");
        // 调用线程主体
        tA.start();
        tB.start();
    }

    static class MyThread implements Runnable {

        private int ticket = 5;

        @Override
        public void run() {
            while (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + " 卖出了第 " + ticket + " 张票");
                ticket--;
            }
        }

    }
}

实现Callable接口

继承 Thread 类 和 实现 Runnable 接口这两种创建线程的方式都没有返回值。所以，线程执行完后，无法得到执行结果。但如果期望得到执行结果该怎么做？

为了解决这个问题，Java 1.5 后，提供了 Callable 接口和 Future 接口，通过它们，可以在线程执行结束后，返回执行结果。

通过实现Callable接口创建线程的步骤：

① 创建 Callable 接口的实现类，并实现 call 方法。该 call 方法将作为线程执行体，并且有返回值。

② 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call 方法的返回值。

③ 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。

④ 调用 FutureTask 对象的 get 方法来获得线程执行结束后的返回值。

public class CallableDemo {

    public static void main(String[] args) {
        Callable<Long> callable = new MyThread();
        FutureTask<Long> future = new FutureTask<>(callable);
        new Thread(future, "Callable 线程").start();
        try {
            System.out.println("任务耗时：" + (future.get() / 1000000) + "毫秒");
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

    static class MyThread implements Callable<Long> {

        private int ticket = 10000;

        @Override
        public Long call() {
            long begin = System.nanoTime();
            while (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + " 卖出了第 " + ticket + " 张票");
                ticket--;
            }

            long end = System.nanoTime();
            return (end - begin);
        }

    }
}

FAQ（经常问到的问题）

start 和 run 方法有什么区别？

  • run 方法是线程的执行体。
  • start 方法会启动线程，然后 JVM 会让这个线程去执行 run 方法。

可以直接调用 Thread 类的 run 方法么？

  • 可以。但是如果直接调用 Thread 的 run 方法，它的行为就会和普通的方法一样。
  • 为了在新的线程中执行我们的代码，必须使用 Thread 的 start 方法。

线程休眠

使用 Thread.sleep 方法可以使得当前正在执行的线程进入休眠状态。

使用 Thread.sleep 需要向其传入一个整数值，这个值表示线程将要休眠的毫秒数。

Thread.sleep 方法可能会抛出 InterruptedException，因为异常不能跨线程传播回 main 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。

public class ThreadSleepDemo {

    public static void main(String[] args) {
        new Thread(new MyThread("线程A", 500)).start();
        new Thread(new MyThread("线程B", 1000)).start();
        new Thread(new MyThread("线程C", 1500)).start();
    }

    static class MyThread implements Runnable {

        /** 线程名称 */
        private String name;

        /** 休眠时间 */
        private int time;

        private MyThread(String name, int time) {
            this.name = name;
            this.time = time;
        }

        @Override
        public void run() {
            try {
                // 休眠指定的时间
                Thread.sleep(this.time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.name + "休眠" + this.time + "毫秒。");
        }

    }
}

线程礼让

Thread.yield 方法的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行 。

该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行。

public class ThreadYieldDemo {

    public static void main(String[] args) {
        MyThread t = new MyThread();
        new Thread(t, "线程A").start();
        new Thread(t, "线程B").start();
    }

    static class MyThread implements Runnable {

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "运行，i = " + i);
                if (i == 2) {
                    System.out.print("线程礼让：");
                    Thread.yield();
                }
            }
        }
    }
}

终止线程

Thread 中的 stop 方法有缺陷，已废弃。

使用 Thread.stop 停止线程会导致它解锁所有已锁定的监视器（由于未经检查的 ThreadDeath 异常会在堆栈中传播，这是自然的结果）。 如果先前由这些监视器保护的任何对象处于不一致状态，则损坏的对象将对其他线程可见，从而可能导致任意行为。Thread.stop的许多用法应由仅修改某些变量以指示目标线程应停止运行的代码代替。 目标线程应定期检查此变量，如果该变量指示要停止运行，则应按有序方式从其运行方法返回。如果目标线程等待很长时间（例如，在条件变量上），则应使用中断方法来中断等待。

当一个线程运行时，另一个线程可以直接通过 interrupt 方法中断其运行状态。

public class ThreadInterruptDemo {

    public static void main(String[] args) {
        MyThread mt = new MyThread(); // 实例化Runnable子类对象
        Thread t = new Thread(mt, "线程"); // 实例化Thread对象
        t.start(); // 启动线程
        try {
            Thread.sleep(2000); // 线程休眠2秒
        } catch (InterruptedException e) {
            System.out.println("3、休眠被终止");
        }
        t.interrupt(); // 中断线程执行
    }

    static class MyThread implements Runnable {

        @Override
        public void run() {
            System.out.println("1、进入run()方法");
            try {
                Thread.sleep(10000); // 线程休眠10秒
                System.out.println("2、已经完成了休眠");
            } catch (InterruptedException e) {
                System.out.println("3、休眠被终止");
                return; // 返回调用处
            }
            System.out.println("4、run()方法正常结束");
        }
    }
}

如果一个线程的 run 方法执行一个无限循环，并且没有执行 sleep 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt 方法就无法使线程提前结束。

但是调用 interrupt 方法会设置线程的中断标记，此时调用 interrupted 方法会返回 true。因此可以在循环体中使用 interrupted 方法来判断线程是否处于中断状态，从而提前结束线程。

安全地终止线程有两种方法：

  • 定义 volatile 标志位，在 run 方法中使用标志位控制线程终止
  • 使用 interrupt 方法和 Thread.interrupted 方法配合使用来控制线程终止

示例：使用 volatile 标志位控制线程终止

public class ThreadStopDemo2 {

    public static void main(String[] args) throws Exception {
        MyTask task = new MyTask();
        Thread thread = new Thread(task, "MyTask");
        thread.start();
        TimeUnit.MILLISECONDS.sleep(50);
        task.cancel();
    }

    private static class MyTask implements Runnable {

        private volatile boolean flag = true;

        private volatile long count = 0L;

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 线程启动");
            while (flag) {
                System.out.println(count++);
            }
            System.out.println(Thread.currentThread().getName() + " 线程终止");
        }

        /**
         * 通过 volatile 标志位来控制线程终止
         */
        public void cancel() {
            flag = false;
        }

    }
}

示例：使用 interrupt 方法和 Thread.interrupted 方法配合使用来控制线程终止

public class ThreadStopDemo3 {

    public static void main(String[] args) throws Exception {
        MyTask task = new MyTask();
        Thread thread = new Thread(task, "MyTask");
        thread.start();
        TimeUnit.MILLISECONDS.sleep(50);
        thread.interrupt();
    }

    private static class MyTask implements Runnable {

        private volatile long count = 0L;

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 线程启动");
            // 通过 Thread.interrupted 和 interrupt 配合来控制线程终止
            while (!Thread.interrupted()) {
                System.out.println(count++);
            }
            System.out.println(Thread.currentThread().getName() + " 线程终止");
        }
    }
}

守护线程

什么是守护线程？

  • 守护线程（Daemon Thread）是在后台执行并且不会阻止 JVM 终止的线程。当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。
  • 与守护线程（Daemon Thread）相反的，叫用户线程（User Thread），也就是非守护线程。

为什么需要守护线程？

  • 守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务。典型的应用就是垃圾回收器。

如何使用守护线程？

① 可以使用 isDaemon 方法判断线程是否为守护线程。
② 可以使用 setDaemon 方法设置线程为守护线程。

  • 正在运行的用户线程无法设置为守护线程，所以 setDaemon 必须在 thread.start 方法之前设置，否则会抛出 llegalThreadStateException 异常；
  • 一个守护线程创建的子线程依然是守护线程。
  • 不要认为所有的应用都可以分配给守护线程来进行服务，比如读写操作或者计算逻辑。
public class ThreadDaemonDemo {

    public static void main(String[] args) {
        Thread t = new Thread(new MyThread(), "线程");
        t.setDaemon(true); // 此线程在后台运行
        System.out.println("线程 t 是否是守护进程：" + t.isDaemon());
        t.start(); // 启动线程
    }

    static class MyThread implements Runnable {

        @Override
        public void run() {
            while (true) {
                System.out.println(Thread.currentThread().getName() + "在运行。");
            }
        }
    }
}

FAQ（经常问到的问题）

sleep、yield、join 方法有什么区别

① yield方法

  • yield 方法会 让线程从 Running 状态转入 Runnable 状态。
  • 当调用了 yield 方法后，只有与当前线程相同或更高优先级的Runnable 状态线程才会获得执行的机会。

② sleep方法

  • sleep 方法会 让线程从 Running 状态转入 Waiting 状态。
  • sleep 方法需要指定等待的时间，超过等待时间后，JVM 会将线程从 Waiting 状态转入 Runnable 状态。
  • 当调用了 sleep 方法后，无论什么优先级的线程都可以得到执行机会。
  • sleep 方法不会释放“锁标志”，也就是说如果有 synchronized 同步块，其他线程仍然不能访问共享数据。

③ join方法

  • join 方法会 让线程从 Running 状态转入 Waiting 状态。
  • 当调用了 join 方法后，当前线程必须等待调用 join 方法的线程结束后才能继续执行。

为什么 sleep 和 yield 方法是静态的

Thread 类的 sleep 和 yield 方法将处理 Running 状态的线程。

所以在其他处于非 Running 状态的线程上执行这两个方法是没有意义的。这就是为什么这些方法是静态的。它们可以在当前正在执行的线程中工作，并避免程序员错误的认为可以在其他非运行线程调用这些方法。

Java 线程是否按照线程优先级严格执行

即使设置了线程的优先级，也无法保证高优先级的线程一定先执行。

原因在于线程优先级依赖于操作系统的支持，然而，不同的操作系统支持的线程优先级并不相同，不能很好的和 Java 中线程优先级一一对应。

三、线程间的通信

当多个线程可以一起工作去解决某个问题时，如果某些部分必须在其它部分之前完成，那么就需要对线程进行协调。

wait / notify / notifyAll

  • wait - wait 方法使得线程释放其占有的对象锁，让线程从 Running 状态转入 Waiting 状态，并等待 notify / notifyAll 来唤醒 。如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify 或者 notifyAll 来唤醒挂起的线程，造成死锁。
  • notify - 唤醒一个正在 Waiting 状态的线程，并让它拿到对象锁，具体唤醒哪一个线程由 JVM 控制 。
  • notifyAll - 唤醒所有正在 Waiting 状态的线程，接下来它们需要竞争对象锁。

wait、notify、notifyAll 都是 Object 类中的方法，而非 Thread。
wait、notify、notifyAll 只能用在 synchronized 方法或者 synchronized 代码块中使用，否则会在运行时抛出 IllegalMonitorStateException。

为什么 wait、notify、notifyAll 不定义在 Thread 中？为什么 wait、notify、notifyAll 要配合 synchronized 使用？

首先，需要了解几个基本知识点：
① 每一个 Java 对象都有一个与之对应的 监视器（monitor）
② 每一个监视器里面都有一个 对象锁 、一个 等待队列、一个 同步队列。
了解了以上概念，我们回过头来理解前面两个问题。

为什么这几个方法不定义在 Thread 中？

由于每个对象都拥有对象锁，让当前线程等待某个对象锁，自然应该基于这个对象（Object）来操作，而非使用当前线程（Thread）来操作。因为当前线程可能会等待多个线程的锁，如果基于线程（Thread）来操作，就非常复杂了。

为什么 wait、notify、notifyAll 要配合 synchronized 使用？

如果调用某个对象的 wait 方法，当前线程必须拥有这个对象的对象锁，因此调用 wait 方法必须在 synchronized 方法和 synchronized 代码块中。

生产者、消费者模式是 wait、notify、notifyAll 的一个经典使用案例：

public class ThreadWaitNotifyDemo02 {

    private static final int QUEUE_SIZE = 10;
    private static final PriorityQueue<Integer> queue = new PriorityQueue<>(QUEUE_SIZE);

    public static void main(String[] args) {
        new Producer("生产者A").start();
        new Producer("生产者B").start();
        new Consumer("消费者A").start();
        new Consumer("消费者B").start();
    }

    static class Consumer extends Thread {

        Consumer(String name) {
            super(name);
        }

        @Override
        public void run() {
            while (true) {
                synchronized (queue) {
                    while (queue.size() == 0) {
                        try {
                            System.out.println("队列空，等待数据");
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notifyAll();
                        }
                    }
                    queue.poll(); // 每次移走队首元素
                    queue.notifyAll();
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 从队列取走一个元素，队列当前有：" + queue.size() + "个元素");
                }
            }
        }
    }

    static class Producer extends Thread {

        Producer(String name) {
            super(name);
        }

        @Override
        public void run() {
            while (true) {
                synchronized (queue) {
                    while (queue.size() == QUEUE_SIZE) {
                        try {
                            System.out.println("队列满，等待有空余空间");
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notifyAll();
                        }
                    }
                    queue.offer(1); // 每次插入一个元素
                    queue.notifyAll();
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 向队列取中插入一个元素，队列当前有：" + queue.size() + "个元素");
                }
            }
        }
    }
}

join

在线程操作中，可以使用 join 方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。

public class ThreadJoinDemo {

    public static void main(String[] args) {
        MyThread mt = new MyThread(); // 实例化Runnable子类对象
        Thread t = new Thread(mt, "myThread"); // 实例化Thread对象
        t.start(); // 启动线程
        for (int i = 0; i < 50; i++) {
            if (i > 10) {
                try {
                    t.join(); // 线程强制运行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Main 线程运行 --> " + i);
        }
    }

    static class MyThread implements Runnable {

        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                System.out.println(Thread.currentThread().getName() + " 运行，i = " + i); // 取得当前线程的名字
            }
        }
    }
}

管道流（线程流）

管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。
管道输入/输出流主要包括了如下 4 种具体实现：PipedOutputStream、PipedInputStream、PipedReader 和 PipedWriter，前两种面向字节，而后两种面向字符。

 
//管道流：
/*让多线程可以通过管道进行线程间的通讯。必须将PipedOutputStream和PipedInputStream配套使用。
大致的流程是：我们在线程A中向PipedOutputStream中写入数据，
这些数据会自动的发送到与PipedOutputStream对应的PipedInputStream中，
进而存储在PipedInputStream的缓冲中；
此时，线程B通过读取PipedInputStream中的数据。就可以实现，线程A和线程B的通信。*/
public class IOTest {
	public static void main(String[] args) throws IOException {
 
		Send send = new Send();
		Recive recive = new Recive();
		try {
			// 管道连接
			send.getOut().connect(recive.getInput());
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread());
		new Thread(send).start();
		new Thread(recive).start();
 
	}
}
 
class Send implements Runnable {
	private PipedOutputStream out = null;
 
	public Send() {
		out = new PipedOutputStream();
	}
 
	public PipedOutputStream getOut() {
		return this.out;
	}
 
	public void run() {
		String message = "hello , Rollen";
		try {
			out.write(message.getBytes());
			System.out.println(Thread.currentThread() + "发送数据成功");
		} catch (Exception e) {
			e.printStackTrace();
		}
		try {
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
 
/**
 * 接受消息类
 */
class Recive implements Runnable {
	private PipedInputStream input = null;
 
	public Recive() {
		this.input = new PipedInputStream();
	}
 
	public PipedInputStream getInput() {
		return this.input;
	}
 
	public void run() {
		byte[] b = new byte[1000];
		int len = 0;
		try {
			len = this.input.read(b);
		} catch (Exception e) {
			e.printStackTrace();
		}
		try {
			input.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread() + "接受的内容为 " + (new String(b, 0, len)));
	}
}

四、线程状态

java.lang.Thread.State 中定义了 6 种不同的线程状态，在给定的一个时刻，线程只能处于其中的一个状态。

以下是各状态的说明，以及状态间的联系：

① 新建（New） - 尚未调用 start 方法的线程处于此状态。此状态意味着：创建的线程尚未启动。

② 可运行（Runnable） - 已经调用了 start 方法的线程处于此状态。此状态意味着：线程已经在 JVM 中运行。但是在操作系统层面，它可能处于运行状态，也可能等待资源调度（例如处理器资源），资源调度完成就进入运行状态。所以该状态的可运行是指可以被运行，具体有没有运行要看底层操作系统的资源调度。

③ 阻塞（Blocked） - 请求获取 monitor lock 从而进入 synchronized 函数或者代码块，但是其它线程已经占用了该 monitor lock，所以处于阻塞状态。要结束该状态进入 Runnable，从而需要其他线程释放 monitor lock。此状态意味着：线程处于被阻塞状态。

③ 等待（Waiting） - 此状态意味着：线程等待被其他线程显式地唤醒。 阻塞和等待的区别在于，阻塞是被动的，它是在等待获取 monitor lock。而等待是主动的，通过调用 Object.wait 等方法进入。

进入方法退出方法
没有设置 Timeout 参数的 Object.wait 方法Object.notify / Object.notifyAll
没有设置 Timeout 参数的 Thread.join 方法被调用的线程执行完毕
LockSupport.park 方法LockSupport.unpark

⑥ 定时等待（Timed waiting） - 此状态意味着：无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。

进入方法退出方法
Thread.sleep 方法时间结束
设置了 Timeout 参数的 Object.wait 方法时间结束 / Object.notify / Object.notifyAll
设置了 Timeout 参数的 Thread.join 方法时间结束 / 被调用的线程执行完毕
LockSupport.parkNanos 方法LockSupport.unpark
LockSupport.parkUntil 方法LockSupport.unpark

⑦ 终止(Terminated) - 线程 run 方法执行结束，或者因异常退出了 run 方法。此状态意味着：线程结束了生命周期。

五、参考

https://www.cnblogs.com/jingmoxukong/p/12096580.html

codedot
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++ Http客户端
04-29
C++ http client，可以直接封装到自身的c++项目中，采用的是linux下的curl库
java多线程—Runnable、Thread、Callable区别
没长正
08-12 1139
java多线程—Runnable、Thread、Callable区别 阅读目录 多线程编程优点第一种实现方法—继承Thread类第二种实现方法—实现Runnable接口第三种—实现Callable接口总结参考 回到顶部 多线程编程优点 进程之间不能共享内存，但线程之间共享内存非常容易。 系统创建线程所分配的资源相对创建进程而言，代价非常小。
四、虚拟机字节码执行引擎
qq_32323239的博客
09-22 411
运行时栈帧结构 Java虚拟机以方法作为最基本的执行单元，“栈帧”（Stack Frame）则是用于支持虚拟机进行方法 调用和方法执行背后的数据结构，它也是虚拟机运行时数据区中的虚拟机栈（Virtual Machine Stack）[1]的栈元素。栈帧存储了方法的局部变量表、操作数栈、动态连接和方法返回地址等信息和一些额外的附加信息。 局部变量表 局部变量表（Local Variables Table）是一组变量值的存储空间，用于存放方法参数和方法内部定义 的局部变量。在Java程序被编译为.
Java - 多线程 Thread、Runnable、Callable的区别
weixin_68429349的博客
10-13 489
在Java中，Thread、Runnable和Callable是用于实现多线程的三种主要方式，它们在用法和功能上有一些区别。然而，继承Thread类只能用于实现简单的线程，对于需要共享资源和复杂线程协作的场景，则不太适用。Runnable的优点是可以避免Java的单继承限制，并且可以更方便地实现共享资源的访问控制。Callable主要用于需要返回结果的任务，而Runnable是不支持返回结果的。方式一：FutureTask类。
Runnable和Thread以及Callable的区别
一只菜橘猫
07-16 5507
Thread 1、是一个类 2、只能被继承 实现方式 class ThreadTest extends Thread{     private int ticket = 100;     public void run(){       while(true){         if(ticket &gt; 0){   ticket-   }else{ break;  }}} new T...
java多线程基础知识
最新发布
01-25
Java多线程基础知识 Java多线程基础知识是Java编程语言中的一项重要技术，用于提高程序的执行效率和响应速度。在这里，我们将详细介绍Java多线程基础知识的相关概念和技术。 一、程序、进程和线程 程序（Program...
Java面试基础知识.doc
11-21
"Java面试基础知识" Java 面试基础知识是 Java 开发者在面试时需要了解的基础知识点。以下是 Java 面试基础知识的重要知识点： 1. Java 的接口和 C++的虚类的雷同和不合处 Java 的接口和 C++ 的虚类有相似之处，...
Java多线程知识点总结
08-19
总之，掌握Java多线程的生命周期、创建、启动、同步以及线程池的使用是编写高效、稳定并发程序的基础。理解这些知识点对于解决并发编程中的问题，比如资源竞争、死锁、线程安全性等问题，至关重要。在实际开发中，...
JAVA多线程入门基础知识
02-22
必知必会的多线程入门基础知识
HTTP Client C++实现
01-15
CHttpClient.rar HTTP Client C++实现
C++ httpclient类
09-03
封装好的http client类，使用方便。
C++使用libcurl做HttpClient
太极语言
02-06 2051
C++使用libcurl做HttpClient 分类： 基础技术分享2012-06-14 19:25 1469人阅读 评论(3) 收藏 举报     当使用C++做HTTP客户端时，目前通用的做法就是使用libcurl。其官方网站的地址是http://curl.haxx.se/，该网站主要提供了Curl和libcurl。Curl是命令行工具，用于完成FTP, FTPS, H
C++实现轻量级极简httpserver和httpclient（提供http和websocket接口）
mark_jl的博客
03-30 2137
一般来说，C++的项目多是偏底层，不怎么需要跟http打交道，但有时候又需要在C++后端项目中加入一些简单 http以及websocket接口，比如游戏运营服务器，金融交易监控服务等。但是传统的实现方法比如采用libcurl，asio等较为重型的框架来做有没有必要，因此，这里采用mongoose这个库来实现基本的httpserver和httpclient功能，非常简单，包含一个h文件，一个cpp文件到工程中就行了，无需编译，无需链接库。
Runnable、Thread、Callable的区别
qq_41634872的博客
04-25 1015
线程实现的方式及区别： Runnable、Thread、Callable 实现 Runnable 接口相比继承 Thread 类有如下优势 1）可以避免由于 Java 的单继承特性而带来的局限 2）增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的 3）线程池只能放入实现 Runable 或 Callable 类线程，不能直接放入继承 Thread 的类 实现 Runnable 接...
Thread类，Runnable接口和Callable接口的区别
Li2992673708的博客
09-13 297
在实际开发中，推荐使用Runnable接口或Callable接口创建线程，因为它们更灵活，并且可以避免由于单继承限制而无法扩展其他类的问题。Runnable接口是一个函数式接口，用于表示一个可运行的任务，通过实现Runnable接口并传递给Thread类来执行任务。Thread类和Runnable接口都不能返回任务的执行结果，而Callable接口可以返回执行结果，并且可以抛出异常。Callable接口也是一个函数式接口，类似于Runnable接口，但可以返回执行结果，并且可以抛出异常。
Java多线程Thread、Runnable、Callable知识点
gb4215287的博客
06-01 483
java三种线程创建方式
纯C实现https请求，跨平台的httpclient库，体积仅100K
meishow88的专栏
05-09 1843
粗略看一下代码，会发现ft_http_client_t结构体并没有翻译出来，这个结构体比较复杂，但是我们可以申明一个type ft_http_client_t as any ptr，然后把ft_http_client_t ptr全部替换为ft_http_client_t。编译完成可以得到libhttpclient.a，体积只有122k，将文件拷贝到Compile\expand\lib\win32文件夹。找了一圈，最终发现有个停更七年的开源项目httpclient，项目地址在。
Java线程基础知识：概念、原理和使用
Java线程知识点总结 Java线程是Java编程语言中的一种基本组件，用于实现多任务处理和并发执行。下面是Java线程的概念、原理和实现方法的知识点总结： 一、操作系统中的线程和进程 * 进程是指一个内存中运行的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

codedot

你的鼓励是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值