多线程

最新推荐文章于 2022-12-24 21:37:24 发布
最新推荐文章于 2022-12-24 21:37:24 发布
阅读量102 收藏
点赞数
分类专栏： 面向对象进阶 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Radiation_x/article/details/112628165
版权

多线程

并发与并行

  • 并行（parallel）：指两个或多个事件在同一时刻发生（同时发生）。指在同一时刻，有多条指令在多个处理器上同时执行。
  • 并发（concurrency）：指两个或多个事件在同一个时间段内发生。指在同一个时刻只能有一条指令执行，但多个进程的指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。

线程与进程

  • 程序：为了完成某个任务和功能，选择一种编程语言编写的一组指令的集合。

  • 软件：1个或多个应用程序+相关的素材和资源文件等构成一个软件系统。

  • 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

  • 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

    简而言之：一个软件中至少有一个应用程序，应用程序的一次运行就是一个进程，一个进程中至少有一个线程。

  • **面试题：**进程是操作系统调度和分配资源的最小单位，线程是CPU调度的最小单位。不同的进程之间是不共享内存的。进程之间的数据交换和通信的成本是很高。不同的线程是共享同一个进程的内存的。当然不同的线程也有自己独立的内存空间。对于方法区，堆中中的同一个对象的内存，线程之间是可以共享的，但是栈的局部变量永远是独立的。

线程调度

  • 分时调度

    所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

  • 抢占式调度

    优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

继承Thread类

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：

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

  2. 创建Thread子类的实例，即创建了线程对象

  3. 调用线程对象的start()方法来启动该线程

    代码如下：

    测试类：

    public class Demo01 {
	public static void main(String[] args) {
		//创建自定义线程对象
		MyThread mt = new MyThread("新的线程！");
		//开启新线程
		mt.start();
		//在主方法中执行for循环
		for (int i = 0; i < 10; i++) {
			System.out.println("main线程！"+i);
		}
	}
}

    自定义线程类：

    public class MyThread extends Thread {
	//定义指定线程名称的构造方法
	public MyThread(String name) {
		//调用父类的String参数的构造方法，指定线程的名称
		super(name);
	}
	/**
	 * 重写run方法，完成该线程执行的逻辑
	 */
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(getName()+"：正在执行！"+i);
		}
	}
}

实现Runnable接口

Java有单继承的限制，当我们无法继承Thread类时，那么该如何做呢？在核心类库中提供了Runnable接口，我们可以实现Runnable接口，重写run()方法，然后再通过Thread类的对象代理启动和执行我们的线程体run()方法

步骤如下：

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

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

  3. 调用线程对象的start()方法来启动线程。

  4. 代码如下：

  public class MyRunnable implements Runnable{
  	@Override  
      public void run() {
          for (int i = 0; i < 20; i++) {
          	System.out.println(Thread.currentThread().getName()+" "+i);         
  		}       
  	}    
  }

  public class Demo {
      public static void main(String[] args) {
          //创建自定义类对象  线程任务对象
          MyRunnable mr = new MyRunnable();
          //创建线程对象
          Thread t = new Thread(mr, "小强");
          t.start();
          for (int i = 0; i < 20; i++) {
              System.out.println("旺财 " + i);
          }
      }
  }

Thread类

构造方法

public Thread() :分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法系列

  • public void run() :此线程要执行的任务在此处定义代码。
  • public String getName() :获取当前线程名称。
  • public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
  • public final boolean isAlive()：测试线程是否处于活动状态。如果线程已经启动且尚未终止，则为活动状态。
  • public final int getPriority() ：返回线程优先级
  • public final void setPriority(int newPriority) ：改变线程的优先级

常用方法系列

  • public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。

  • public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。

  • public static void yield()：yield只是让当前线程暂停一下，让系统的线程调度器重新调度一次，希望优先级与当前线程相同或更高的其他线程能够获得执行机会，但是这个不能保证，完全有可能的情况是，当某个线程调用了yield方法暂停之后，线程调度器又将其调度出来重新执行。

  • void join() ：等待该线程终止。

    void join(long millis) ：等待该线程终止的时间最长为 millis 毫秒。如果millis时间到，将不再等待。

    void join(long millis, int nanos) ：等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。

  • public final void stop()：强迫线程停止执行。 该方法具有固有的不安全性，已经标记为@Deprecated不建议再使用，那么我们就需要通过其他方式来停止线程了，其中一种方式是使用变量的值的变化来控制线程是否结束。

线程安全

当我们使用多个线程访问同一资源（可以是同一个变量、同一个文件、同一条记录等）的时候，若多个线程只有读操作，那么不会发生线程安全问题，但是如果多个线程中对资源有读和写的操作，就容易出现线程安全问题。
要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制
(synchronized)来解决。

同步代码块

  • 同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
    格式:

    synchronized(同步锁){
     需要同步操作的代码
}
    • 同步锁:
      对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

    ​ 锁对象 可以是任意类型。

    ​ 多个线程对象 要使用同一把锁。
    注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。
    使用同步代码块解决代码：

    public class Ticket implements Runnable {
	private int ticket = 100;

	/*
	 * 执行卖票操作
	 */
	@Override
	public void run() {
		// 每个窗口卖票的操作
		// 窗口永远开启
        while (true) {
            synchronized (this) {//这里可以选择this作为锁，是因为对于这几个线程，Ticket的this是同一个 
                if (ticket > 0) {// 有票可以卖
                    // 出票操作
                    // 使用sleep模拟一下出票时间
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 获取当前线程对象的名字
                    String name = Thread.currentThread().getName();
                    System.out.println(name + "正在卖:" + ticket--);
                }
			}
        }
	}
}

    当使用了同步代码块后，上述的线程的安全问题，解决了。

    class Ticket extends Thread{
	private static int ticket = 100;

	public Ticket() {
		super();
	}

	public Ticket(String name) {
		super(name);
	}

	/*
	 * 执行卖票操作
	 */
	@Override
	public void run() {
		// 每个窗口卖票的操作
		// 窗口永远开启
		while (true) {
			synchronized (Ticket.class) {//这里不能选用this作为锁，因为这几个线程的this不是同一个
				if (ticket > 0) { // 有票可以卖
	                // 出票操作
	                // 使用sleep模拟一下出票时间
	                try {
	                    Thread.sleep(100);
	                } catch (InterruptedException e) {
	                    e.printStackTrace();
	                }
	                // 获取当前线程对象的名字
	                System.out.println(getName() + "正在卖:" + ticket--);
	            }
			}
		}
	}
}

同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外
等着

格式：

public synchronized void method(){
    可能会产生线程安全问题的代码
}

同步方法的锁对象：

（1）静态方法：当前类的Class对象

（2）非静态方法：this

使用同步方法代码如下：

public class Ticket implements Runnable{
	private int ticket = 100;   
	/*
	 * 执行卖票操作   
	 */  
	@Override 
	public void run() {	    
	//每个窗口卖票的操作 	        
	//窗口 永远开启 	        
		while(true){        
			sellTicket();            
		}        
	}
		        
		/*   
		 * 锁对象 是 谁调用这个方法 就是谁     
		 *   隐含 锁对象 就是  this    
		 *    	    
		 */
	    
	public synchronized void sellTicket(){
		if(ticket>0){//有票 可以卖   
		  //出票操作
		  //使用sleep模拟一下出票时间 
			try {              
				Thread.sleep(100);
			} catch (InterruptedException e) {
  				e.printStackTrace();
			}
        
            //获取当前线程对象的名字 
            String name = Thread.currentThread().getName();
            System.out.println(name+"正在卖:"+ticket‐‐);
        }
   }
}

class Ticket extends Thread {
	private static int ticket = 100;

	public Ticket() {
		super();
	}

	public Ticket(String name) {
		super(name);
	}

	/*
	 * 执行卖票操作
	 */
	@Override
	public void run() {
		// 每个窗口卖票的操作
		// 窗口永远开启
		while (true) {
			sellTicket();
		}
	}
	//这里必须是静态方法，因为如果是非静态方法，隐含的锁对象是this，那么多个线程就不是同一个锁对象了
	//而静态方法隐含的锁对象是当前类的Class对象
	public synchronized static void sellTicket(){
		if(ticket>0){//有票可以卖 
			//出票操作
			//使用sleep模拟一下出票时间
			try {
				Thread.sleep(100);
			} catch(InterruptedException e) {
				e.printStackTrace();
			}
			//获取当前线程对象的名字
			String name = Thread.currentThread().getName();
			System.out.println(name + "正在卖：" + ticket--);
		}
	}

}

等待唤醒机制

这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就好比在公司里你和你的同事们，你们可能存在在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。

就是在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。

wait/notify 就是线程间的一种协作机制。

等待唤醒中的方法

等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：

  1. wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
  2. notify：则选取所通知对象的 wait set 中的一个线程释放；
  3. notifyAll：则释放所通知对象的 wait set 上的全部线程。

注意：

哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。

总结如下：

  • 如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE（可运行） 状态；
  • 否则，线程就从 WAITING 状态又变成 BLOCKED（等待锁） 状态

调用wait和notify方法需要注意的细节

  1. wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
  2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
  3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。

线程生命周期

简单来说，线程的生命周期有五种状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、死亡（Dead）。CPU需要在多条线程之间切换，于是线程状态会多次在运行、阻塞、就绪之间切换。

1. 新建

当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状。此时它和其他Java对象一样，仅仅由JVM为其分配了内存，并初始化了实例变量的值。此时的线程对象并没有任何线程的动态特征，程序也不会执行它的线程体run()。

2. 就绪

但是当线程对象调用了start()方法之后，就不一样了，线程就从新建状态转为就绪状态。JVM会为其创建方法调用栈和程序计数器，当然，处于这个状态中的线程并没有开始运行，只是表示已具备了运行的条件，随时可以被调度。至于什么时候被调度，取决于JVM里线程调度器的调度。

注意：

程序只能对新建状态的线程调用start()，并且只能调用一次，如果对非新建状态的线程，如已启动的线程或已死亡的线程调用start()都会报错IllegalThreadStateException异常。

3. 运行

如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程体代码，则该线程处于运行状态。如果计算机只有一个CPU，在任何时刻只有一个线程处于运行状态，如果计算机有多个处理器，将会有多个线程并行(Parallel)执行。

当然，美好的时光总是短暂的，而且CPU讲究雨露均沾。对于抢占式策略的系统而言，系统会给每个可执行的线程一个小时间段来处理任务，当该时间用完，系统会剥夺该线程所占用的资源，让其回到就绪状态等待下一次被调度。此时其他线程将获得执行机会，而在选择下一个线程时，系统会适当考虑线程的优先级。

4. 阻塞

当在运行过程中的线程遇到如下情况时，线程会进入阻塞状态：

  • 线程调用了sleep()方法，主动放弃所占用的CPU资源；
  • 线程试图获取一个同步监视器，但该同步监视器正被其他线程持有；
  • 线程执行过程中，同步监视器调用了wait()，让它等待某个通知（notify）；
  • 线程执行过程中，同步监视器调用了wait(time)
  • 线程执行过程中，遇到了其他线程对象的加塞（join）；
  • 线程被调用suspend方法被挂起（已过时，因为容易发生死锁）；

当前正在执行的线程被阻塞后，其他线程就有机会执行了。针对如上情况，当发生如下情况时会解除阻塞，让该线程重新进入就绪状态，等待线程调度器再次调度它：

  • 线程的sleep()时间到；
  • 线程成功获得了同步监视器；
  • 线程等到了通知(notify)；
  • 线程wait的时间到了
  • 加塞的线程结束了；
  • 被挂起的线程又被调用了resume恢复方法（已过时，因为容易发生死锁）；

5. 死亡

线程会以以下三种方式之一结束，结束后的线程就处于死亡状态：

  • run()方法执行完成，线程正常结束
  • 线程执行过程中抛出了一个未捕获的异常（Exception）或错误（Error）
  • 直接调用该线程的stop()来结束该线程（已过时，因为容易发生死锁）

不过在java.lang.Thread.State的枚举类中这样定义：

    public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }
  • 首先它没有区分：就绪和运行状态，因为对于Java对象来说，只能标记为可运行，至于什么时候运行，不是JVM来控制的了，是OS来进行调度的，而且时间非常短暂，因此对于Java对象的状态来说，无法区分。只能我们人为的进行想象和理解。
  • 其次根据Thread.State的定义，阻塞状态是分为三种的：BLOCKED、WAITING、TIMED_WAITING。

Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
总结：
实现Runnable接口比继承Thread类所具有的优势：

  1. 适合多个相同的程序代码的线程去共享同一个资源。
  2. 可以避免java中的单继承的局限性。
  3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
  4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
  5. 扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用
    java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进
    程。

11.8 释放锁操作与死锁

任何线程进入同步代码块、同步方法之前，必须先获得对同步监视器的锁定，那么何时会释放对同步监视器的锁定呢？

1、释放锁的操作

当前线程的同步方法、同步代码块执行结束。

当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。

当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致当前线程异常结束。

当前线程在同步代码块、同步方法中执行了锁对象的wait()方法，当前线程被挂起，并释放锁。

2、不会释放锁的操作

线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行。

线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该该线程挂起，该线程不会释放锁（同步监视器）。应尽量避免使用suspend()和resume()这样的过时来控制线程。

3、死锁

不同的线程分别锁住对方需要的同步监视器对象不释放，都在等待对方先放弃时就形成了线程的死锁。一旦出现死锁，整个程序既不会发生异常，也不会给出任何提示，只是所有线程处于阻塞状态，无法继续。

public class TestDeadLock {
	public static void main(String[] args) {
		Object g = new Object();
		Object m = new Object();
		Owner s = new Owner(g,m);
		Customer c = new Customer(g,m);
		new Thread(s).start();
		new Thread(c).start();
	}
}
class Owner implements Runnable{
	private Object goods;
	private Object money;

	public Owner(Object goods, Object money) {
		super();
		this.goods = goods;
		this.money = money;
	}

	@Override
	public void run() {
		synchronized (goods) {
			System.out.println("先给钱");
			synchronized (money) {
				System.out.println("发货");
			}
		}
	}
}
class Customer implements Runnable{
	private Object goods;
	private Object money;

	public Customer(Object goods, Object money) {
		super();
		this.goods = goods;
		this.money = money;
	}

	@Override
	public void run() {
		synchronized (money) {
			System.out.println("先发货");
			synchronized (goods) {
				System.out.println("再给钱");
			}
		}
	}
}

4、sleep()和wait()方法的区别

（1）sleep()不释放锁，wait()释放锁

（2）sleep()指定休眠的时间，wait()可以指定时间也可以无限等待直到notify或notifyAll

（3）sleep()在Thread类中声明的静态方法，wait方法在Object类中声明

因为我们调用wait（）方法是由锁对象调用，而锁对象的类型是任意类型的对象。那么希望任意类型的对象都要有的方法，只能声明在Object类中。

Radiation_x
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
04Java多线程
qq_41668667的博客
11-04 156
1. 多线程 1. 基本概念 并发：指两个或多个事件在同一个时间段内发生 并行：指两个或多个事件在同一时刻发生（同时发生） 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
dwr java有返回值但是js获取不到返回值_终于，有大佬通过JS代码讲清楚了Java中的逃逸分析......
weixin_36024829的博客
12-25 230
作者：一叶知秋来源：https://muyinchen.github.io/说到域，假如给小学生中学生或者没有学过编程语言的人理解，更好说明其本质，就是作用范围，而这也就是上下文的意思，无须去理解的那么抽象。接下来就从函数讲起这里拿js的闭包来说，不解释那么多，贴几段代码的，变量的作用域无非就是两种：全局变量和局部变量。Javascript语言的特殊之处，就在于函数内部可以直接读取全局变量。Js代...
dwr调用返回值问题
haidifotiaoqiang
08-11 193
我在用dwr+spring的时候遇到这样的问题，调用一个方法得到一个装有对象列表的ArrayList,如下： getKwdType方法如下： public ArrayList getKwdType() throws Exception{ ArrayList list = new ArrayList(); StringBuffer sql = new Stri...
java中override快捷键_Java高级应用简笔
weixin_39769703的博客
11-14 668
1. Annotation使用范围: package, class, method, field 　　常用: @Override, @Deprecated, @SuppressWarnings 　　自定义注解: 　　　　@Target(ElementType.FIELD) 　　　　public @interface Person{ 　　　　　　String name() def...
使用DWR，不能取值的奇怪问题
topcloud
08-31 133
Javascript代码：   &lt;script type=&lt; span=""&gt;"text/javascript"&gt;   /**  *  保存信息  */   function saveUpline(){       var formObj = dwr.util.getFormValues("e...
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
Linux 多线程原理深剖
最新发布
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
dwr java有返回值但是js获取不到返回值_js逆向 | W博模拟登录流程分析和实现
weixin_28705579的博客
12-25 149
一个人拥有此生此世是不够的，他还应该拥有诗意的世界。1、流程分析本文只作为技术分享，如有侵权请联系本人删除。感谢b站up主留樱雅子的技术分享！一、目标网站aHR0cHM6Ly93ZWliby5jb20v针对页面登陆入口分析二、实现流程分析首先需要明确下登录的目的，是为了获取登录后的cookie，然后携带着cookie去请求页面采集资源。为了达到这个目的，我们需要知道cookie是...
java无法get出数据_java – 不能在我的Future参数上使用get mothod来获取具有可调用接口的线程的结果...
weixin_31448343的博客
02-26 315
我正在尝试构建一个多线程应用程序,可以计算素数(在另一个类中完成的计算),通过使用其他类的方法通过线程,我需要将结果传递给另一个类,以便打印结果.我的问题是,我的可调用线程应该返回一个列表类型,所以当我尝试使用futures.get()时,编译器无法识别我的数据类型ExecutorService executor = Executors.newFixedThreadPool(10);Callabl...
java多线程（一）
qq_34172041的博客
03-05 143
Java多线程 概念 什么是多线程 具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。 软件多线程：即便处理器只能运行一个线程，操作系统也可以通过快速的在不同线程之间进行切换，由于时间间隔很小，来给用户造成一种多个线程同时运行的假象。 多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。cpu核心数增加，计算机并行计算能力提升，若同一个时刻一个线程只能运行在一个cpu上，那么计算机的资源被浪费了 为了提高系统的响应速度，如果系统只有一个线程可以执行，
Java 多线程编程
伴夏微凉的博客
03-21 708
Java 多线程编程 一、进程与线程 进程 应用程序的执行实例。 有独立的内存空间和系统资源 线程 CPU调度和分派的基本单位 进程中执行运算的最小单位，可完成一个独立的顺序控制流程 简而言之： 一个程序至少有一个进程，一个进程至少有一个线程。 线程的划分尺度小于进程，使得多进程程序的并发性高。 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高...
Java线程详解（深度好文）
热门推荐
yjsz2010的专栏
09-16 9万+
转自：https://blog.csdn.net/kwame211/article/details/78963044 Java线程：概念与原理 一、进程与线程           进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，即进程空间或（虚空间）。进程不依赖于线程而独立存在，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。 ...
在DWR中实现直接获取一个JAVA类的返回值
mingxunzh的专栏
10-02 1013
在DWR中实现直接获取一个JAVA类的返回值    DWR是Ajax的一个开源框架，可以很方便是实现调用远程Java类。但是，DWR只能采用回调函数的方法，在回调函数中获取返回值，然后进行处理。那么，到底有没有办法直接获取一个方法的放回值呢？    下面我写一个简单的Java类，如下：public class Test(){    public String getString()    { 
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值