「java线程负载」java线程占用多大内存

admin 2023-03-17 06:00:27 714

本篇文章给大家谈谈java线程负载，以及java线程占用多大内存对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

1、java线程
2、java多线程理解
3、java 线程状态
4、Java多线程实现异步调用
5、在Java 中多线程的实现方法有哪些，如何使用

java线程

Thread t=new Thread(tt); 这一句的作用就是生成线程t啊，生成线程使用new Thread()时必须赋之参数，而该参数必须是实现了 Runnable 的类的对象。

可以合并成一句啊，如下：

Thread t=new Thread(new TestThread());

java多线程理解

线程是系统调度中的最小单位，因为其拥有比进程更小的资源消耗，因此，在进行同类事情，需要进行互相的通讯等等事情的时候，都采用线程来进行处理。

对于只做固定的一件事情（比如：计算1+2+3+...+9999999）来说，其性能上不会比采用单线程的整体效率高，原因是，同时都是要做这么多运算，采用多线程的话，系统在进行线程调度的过程中喙浪费一些资源和时间，从而性能上下降。

那么，多线程是否就没有存在的意义了呢？答案当然不是的。多线程还是有存在的价值的，我们在写输入流输出流，写网络程序等等的时候，都会出现阻塞的情况，如果说，我们不使用多线程的话，从A中读数据出来的时候，A因为没有准备好，而整个程序阻塞了，其他的任何事情都没法进行。如果采用多线程的话，你就不用担心这个问题了。还举个例子：游戏中，如果A角色和B角色采用同一个线程来处理的话，那么，很有可能就会出现只会响应A角色的操作，而B角色就始终被占用了的情况，这样，玩起来肯定就没劲了。

因此，线程是有用的，但也不是随便乱用，乱用的话，可能造成性能的低下，它是有一点的适用范围的，一般我认为：需要响应多个人的事情，从设计上需要考虑同时做一些事情（这些事情很多情况下可能一点关系都没有，也有可能有一些关系的）。

使用多线程的时候，如果某些线程之间涉及到资源共享、互相通讯等等问题的时候，一定得注意线程安全的问题，根据情况看是不是需要使用synchronized关键字。

java 线程状态

第一：当线程处于死亡状态，它的资源肯定会被回收的。

第二：如果一个线程处于死亡状态，那它的资源就会被回收，也意味着该线程消失了，所以要想重新运行，那就得重新调用start方法了，不过重新运行的线程将是一个全新的线程，和已死亡的线程无关！

第三：所谓强制杀死线程，也就是意味着退出了run()方法，故而很简单，在你的run()方法中加入一个return就行了。interrupted()方法仅仅是判断线程是否被中断过，这个用了也没效果！

Java多线程实现异步调用

在JAVA平台实现异步调用的角色有如下三个角色:调用者提货单真实数据一个调用者在调用耗时操作不能立即返回数据时先返回一个提货单然后在过一断时间后凭提货单来获取真正的数据去蛋糕店买蛋糕不需要等蛋糕做出来（假设现做要很长时间）只需要领个提货单就可以了（去干别的事情）等到蛋糕做好了再拿提货单取蛋糕就可以了 public class Main { public static void main(String[] args) {

System out println( main BEGIN );

Host host = new Host();

Data data = host request( A );

Data data = host request( B );

Data data = host request( C );

System out println( main otherJob BEGIN );

try {

Thread sleep( );

} catch (InterruptedException e) {

}

System out println( main otherJob END );

System out println( data = + data getContent());

System out println( main END );

}

这里的main类就相当于顾客 host就相当于蛋糕店顾客向蛋糕店定蛋糕就相当于发请求request 返回的数据data是FutureData的实例就相当于提货单而不是真正的蛋糕在过一段时间后（sleep一段时间后）调用data getContent() 也就是拿提货单获取执行结果

下面来看一下顾客定蛋糕后蛋糕店做了什么

public class Host {

public Data request(final int count final char c) {

System out println( request( + count + + c + ) BEGIN );

// ( ) 建立FutureData的实体

final FutureData future = new FutureData();

// ( ) 为了建立RealData的实体启动新的线程

new Thread() {

public void run() {

//在匿名内部类中使用count future c

RealData realdata = new RealData(count c);

future setRealData(realdata);

}

} start();

System out println( request( + count + + c + ) END );

// ( ) 取回FutureData实体作为传回值

return future;

}

host( 蛋糕店 )在接到请求后先生成了提货单 FutureData的实例future 然后命令蛋糕师傅 RealData去做蛋糕 realdata相当于起个线程去做蛋糕了然后host返回给顾客的仅仅是提货单 future 而不是蛋糕当蛋糕做好后蛋糕师傅才能给对应的提货单蛋糕也就是future setRealData(realdata)

下面来看看蛋糕师傅是怎么做蛋糕的

建立一个字符串包含count个c字符为了表现出犯法需要花费一些时间使用了sleep

public class RealData implements Data { private final String content;

public RealData(int count char c) {

System out println( making RealData( + count + + c + ) BEGIN );

char[] buffer = new char[count];

for (int i = ; i count; i++) {

buffer[i] = c;

try {

Thread sleep( );

} catch (InterruptedException e) {

}

System out println( making RealData( + count + + c + ) END );

ntent = new String(buffer);

}

public String getContent() {

return content;

}

现在来看看提货单 future是怎么与蛋糕 content 对应的:

public class FutureData implements Data { private RealData realdata = null;

private boolean ready = false;

public synchronized void setRealData(RealData realdata) {

if (ready) {

return; // 防止setRealData被调用两次以上

}

this realdata = realdata;

this ready = true;

notifyAll();

}

public synchronized String getContent() {

while (!ready) {

try {

wait();

} catch (InterruptedException e) {

}

return realdata getContent();

}

顾客做完自己的事情后会拿着自己的提货单来取蛋糕

System out println( data = + data getContent());

这时候如果蛋糕没做好就只好等了

while (!ready) { try {

wait();

} catch (InterruptedException e) {

}

//等做好后才能取到

return realdata getContent();

程序分析

对于每个请求 host都会生成一个线程这个线程负责生成顾客需要的蛋糕在等待一段时间以后如果蛋糕还没有做好顾客还必须等待直到蛋糕被做好也就是

future setRealData(realdata); 执行以后顾客才能拿走蛋糕

每个线程只是专门负责制作特定顾客所需要的蛋糕也就是顾客A对应着蛋糕师傅A 顾客B对应着蛋糕师傅B 即使顾客B的蛋糕被先做好了顾客A也只能等待蛋糕师傅A把蛋糕做好换句话说顾客之间没有竞争关系

lishixinzhi/Article/program/Java/gj/201311/27425

在Java 中多线程的实现方法有哪些，如何使用

Java多线程的创建及启动

Java中线程的创建常见有如三种基本形式

1.继承Thread类，重写该类的run()方法。

复制代码

1 class MyThread extends Thread {

3 private int i = 0;

5 @Override

6 public void run() {

7 for (i = 0; i 100; i++) {

8 System.out.println(Thread.currentThread().getName() + " " + i);

9 }

10 }

11 }

复制代码

1 public class ThreadTest {

3 public static void main(String[] args) {

4 for (int i = 0; i 100; i++) {

5 System.out.println(Thread.currentThread().getName() + " " + i);

6 if (i == 30) {

7 Thread myThread1 = new MyThread(); // 创建一个新的线程 myThread1 此线程进入新建状态

8 Thread myThread2 = new MyThread(); // 创建一个新的线程 myThread2 此线程进入新建状态

9 myThread1.start(); // 调用start()方法使得线程进入就绪状态

10 myThread2.start(); // 调用start()方法使得线程进入就绪状态

11 }

12 }

13 }

14 }

复制代码

如上所示，继承Thread类，通过重写run()方法定义了一个新的线程类MyThread，其中run()方法的方法体代表了线程需要完成的任务，称之为线程执行体。当创建此线程类对象时一个新的线程得以创建，并进入到线程新建状态。通过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不一定会马上得以执行，这取决于CPU调度时机。

2.实现Runnable接口，并重写该接口的run()方法，该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。

复制代码

1 class MyRunnable implements Runnable {

2 private int i = 0;

4 @Override

5 public void run() {

6 for (i = 0; i 100; i++) {

7 System.out.println(Thread.currentThread().getName() + " " + i);

8 }

9 }

10 }

复制代码

1 public class ThreadTest {

3 public static void main(String[] args) {

4 for (int i = 0; i 100; i++) {

5 System.out.println(Thread.currentThread().getName() + " " + i);

6 if (i == 30) {

7 Runnable myRunnable = new MyRunnable(); // 创建一个Runnable实现类的对象

8 Thread thread1 = new Thread(myRunnable); // 将myRunnable作为Thread target创建新的线程

9 Thread thread2 = new Thread(myRunnable);

10 thread1.start(); // 调用start()方法使得线程进入就绪状态

11 thread2.start();

12 }

13 }

14 }

15 }

复制代码

相信以上两种创建新线程的方式大家都很熟悉了，那么Thread和Runnable之间到底是什么关系呢？我们首先来看一下下面这个例子。

复制代码

1 public class ThreadTest {

3 public static void main(String[] args) {

4 for (int i = 0; i 100; i++) {

5 System.out.println(Thread.currentThread().getName() + " " + i);

6 if (i == 30) {

7 Runnable myRunnable = new MyRunnable();

8 Thread thread = new MyThread(myRunnable);

9 thread.start();

10 }

11 }

12 }

13 }

15 class MyRunnable implements Runnable {

16 private int i = 0;

18 @Override

19 public void run() {

20 System.out.println("in MyRunnable run");

21 for (i = 0; i 100; i++) {

22 System.out.println(Thread.currentThread().getName() + " " + i);

23 }

24 }

25 }

27 class MyThread extends Thread {

29 private int i = 0;

31 public MyThread(Runnable runnable){

32 super(runnable);

33 }

35 @Override

36 public void run() {

37 System.out.println("in MyThread run");

38 for (i = 0; i 100; i++) {

39 System.out.println(Thread.currentThread().getName() + " " + i);

40 }

41 }

42 }

复制代码

同样的，与实现Runnable接口创建线程方式相似，不同的地方在于

1 Thread thread = new MyThread(myRunnable);

那么这种方式可以顺利创建出一个新的线程么？答案是肯定的。至于此时的线程执行体到底是MyRunnable接口中的run()方法还是MyThread类中的run()方法呢？通过输出我们知道线程执行体是MyThread类中的run()方法。其实原因很简单，因为Thread类本身也是实现了Runnable接口，而run()方法最先是在Runnable接口中定义的方法。

1 public interface Runnable {

3 public abstract void run();

5 }

我们看一下Thread类中对Runnable接口中run()方法的实现：

复制代码

@Override

public void run() {

if (target != null) {

target.run();

}

复制代码

也就是说，当执行到Thread类中的run()方法时，会首先判断target是否存在，存在则执行target中的run()方法，也就是实现了Runnable接口并重写了run()方法的类中的run()方法。但是上述给到的列子中，由于多态的存在，根本就没有执行到Thread类中的run()方法，而是直接先执行了运行时类型即MyThread类中的run()方法。

3.使用Callable和Future接口创建线程。具体是创建Callable接口的实现类，并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程。

看着好像有点复杂，直接来看一个例子就清晰了。

复制代码

1 public class ThreadTest {

3 public static void main(String[] args) {

5 CallableInteger myCallable = new MyCallable(); // 创建MyCallable对象

6 FutureTaskInteger ft = new FutureTaskInteger(myCallable); //使用FutureTask来包装MyCallable对象

8 for (int i = 0; i 100; i++) {

9 System.out.println(Thread.currentThread().getName() + " " + i);

10 if (i == 30) {

11 Thread thread = new Thread(ft); //FutureTask对象作为Thread对象的target创建新的线程

12 thread.start(); //线程进入到就绪状态

13 }

14 }

16 System.out.println("主线程for循环执行完毕..");

18 try {

19 int sum = ft.get(); //取得新创建的新线程中的call()方法返回的结果

20 System.out.println("sum = " + sum);

21 } catch (InterruptedException e) {

22 e.printStackTrace();

23 } catch (ExecutionException e) {

24 e.printStackTrace();

25 }

27 }

28 }

31 class MyCallable implements CallableInteger {

32 private int i = 0;

34 // 与run()方法不同的是，call()方法具有返回值

35 @Override

36 public Integer call() {

37 int sum = 0;

38 for (; i 100; i++) {

39 System.out.println(Thread.currentThread().getName() + " " + i);

40 sum += i;

41 }

42 return sum;

43 }

45 }

复制代码

首先，我们发现，在实现Callable接口中，此时不再是run()方法了，而是call()方法，此call()方法作为线程执行体，同时还具有返回值！在创建新的线程时，是通过FutureTask来包装MyCallable对象，同时作为了Thread对象的target。那么看下FutureTask类的定义：

1 public class FutureTaskV implements RunnableFutureV {

3 //....

5 }

1 public interface RunnableFutureV extends Runnable, FutureV {

3 void run();

5 }

于是，我们发现FutureTask类实际上是同时实现了Runnable和Future接口，由此才使得其具有Future和Runnable双重特性。通过Runnable特性，可以作为Thread对象的target，而Future特性，使得其可以取得新创建线程中的call()方法的返回值。

执行下此程序，我们发现sum = 4950永远都是最后输出的。而“主线程for循环执行完毕..”则很可能是在子线程循环中间输出。由CPU的线程调度机制，我们知道，“主线程for循环执行完毕..”的输出时机是没有任何问题的，那么为什么sum =4950会永远最后输出呢？

原因在于通过ft.get()方法获取子线程call()方法的返回值时，当子线程此方法还未执行完毕，ft.get()方法会一直阻塞，直到call()方法执行完毕才能取到返回值。

上述主要讲解了三种常见的线程创建方式，对于线程的启动而言，都是调用线程对象的start()方法，需要特别注意的是：不能对同一线程对象两次调用start()方法。

你好，本题已解答,如果满意

请点右下角“采纳答案”。

java线程负载的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java线程占用多大内存、java线程负载的信息别忘了在本站进行查找喔。

标签：java线程负载