java多线程为什么不断运行 这个多线程java程序为什么会最开始执行同一个线程两次

大家好，今天来为大家分享java多线程为什么不断运行的一些知识点，和这个多线程java程序为什么会最开始执行同一个线程两次的问题解析，大家要是都明白，那么可以忽略，如果不太清楚的话可以看看本篇文章，相信很大概率可以解决您的问题，接下来我们就一起来看看吧！

java多线程是怎么回事

进程是程序在处理机中的一次运行。一个进程既包括其所要执行的指令，也包括了执行指令所需的系统资源，不同进程所占用的系统资源相对独立。所以进程是重量级的任务，它们之间的通信和转换都需要操作系统付出较大的开销。

线程是进程中的一个实体，是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源，但它可以与同属一个进程的其他线程共享进程所拥有的全部资源。所以线程是轻量级的任务，它们之间的通信和转换只需要较小的系统开销。

Java支持多线程编程，因此用Java编写的应用程序可以同时执行多个任务。Java的多线程机制使用起来非常方便，用户只需关注程序细节的实现，而不用担心后台的多任务系统。

Java语言里，线程表现为线程类。Thread线程类封装了所有需要的线程操作控制。在设计程序时，必须很清晰地区分开线程对象和运行线程，可以将线程对象看作是运行线程的控制面板。在线程对象里有很多方法来控制一个线程是否运行，睡眠，挂起或停止。线程类是控制线程行为的唯一的手段。一旦一个Java程序启动后，就已经有一个线程在运行。可通过调用Thread.currentThread方法来查看当前运行的是哪一个线程。

class ThreadTest{

public static void main(String args[]){

Thread t= Thread.currentThread();

t.setName("单线程");//对线程取名为"单线程"

t.setPriority(8);

//设置线程优先级为8，最高为10，最低为1，默认为5

System.out.println("The running thread:"+ t);

//显示线程信息

try{

for(int i=0;i<3;i++){

System.out.println("Sleep time"+ i);

Thread.sleep(100);//睡眠100毫秒

}

}catch(InterruptedException e){//捕获异常

System.out.println("thread has wrong");

}

}

}

多线程的实现方法

继承Thread类

可通过继承Thread类并重写其中的run()方法来定义线程体以实现线程的具体行为，然后创建该子类的对象以创建线程。

在继承Thread类的子类ThreadSubclassName中重写run()方法来定义线程体的一般格式为:

public class ThreadSubclassName extends Thread{

public ThreadSubclassName(){

.....//编写子类的构造方法，可缺省

}

public void run(){

.....//编写自己的线程代码

}

}

用定义的线程子类ThreadSubclassName创建线程对象的一般格式为:

ThreadSubclassName ThreadObject=

new ThreadSubclassName();

然后，就可启动该线程对象表示的线程：

ThreadObject.start();//启动线程

应用继承类Thread的方法实现多线程的程序。本程序创建了三个单独的线程，它们分别打印自己的“Hello World!”。

class ThreadDemo extends Thread{

private String whoami;

private int delay;

public ThreadDemo(String s,int d){

whoami=s;

delay=d;

}

public void run(){

try{

sleep(delay);

}catch(InterruptedException e){}

System.out.println("Hello World!"+ whoami

+""+ delay);

}

}

public class MultiThread{

public static void main(String args[]){

ThreadDemo t1,t2,t3;

t1= new ThreadDemo("Thread1",

(int)(Math.random()*2000));

t2= new ThreadDemo("Thread2",

(int)(Math.random()*2000));

t3= new ThreadDemo("Thread3",

(int)(Math.random()*2000));

t1.start();

t2.start();

t3.start();

}

}

实现Runnable接口

编写多线程程序的另一种的方法是实现Runnable接口。在一个类中实现Runnable接口(以后称实现Runnable接口的类为Runnable类),并在该类中定义run()方法，然后用带有Runnable参数的Thread类构造方法创建线程。

创建线程对象可用下面的两个步骤来完成:

(1)生成Runnable类ClassName的对象

ClassName RunnableObject= new ClassName();

(2)用带有Runnable参数的Thread类构造方法创建线程对象。新创建的线程的指针将指向Runnable类的实例。用该Runnable类的实例为线程提供 run()方法---线程体。

Thread ThreadObject= new Thread(RunnableObject);

然后，就可启动线程对象ThreadObject表示的线程：

ThreadObject.start();

在Thread类中带有Runnable接口的构造方法有:

public Thread(Runnable target);

public Thread(Runnable target, String name);

public Thread(String name);

public Thread(ThreadGroup group，Runnable target);

public Thread(ThreadGroup group，Runnable target，

String name);

其中，参数Runnable target表示该线程执行时运行target的run()方法，String name以指定名字构造线程，ThreadGroup group表示创建线程组。

用Runnable接口实现的多线程。

class TwoThread implements Runnable{

TwoThread(){

Thread t1= Thread.currentThread();

t1.setName("第一主线程");

System.out.println("正在运行的线程:"+ t1);

Thread t2= new Thread(this,"第二线程");

System.out.println("创建第二线程");

t2.start();

try{

System.out.println("第一线程休眠");

Thread.sleep(3000);

}catch(InterruptedException e){

System.out.println("第一线程有错");

}

System.out.println("第一线程退出");

}

public void run(){

try{

for(int i= 0;i< 5;i++){

System.out.println(“第二线程的休眠时间：”

+ i);

Thread.sleep(1000);

}

}catch(InterruptedException e){

System.out.println("线程有错");

}

System.out.println("第二线程退出");

}

public static void main(String args[]){

new TwoThread();

}

}

程序运行结果如下：

正在运行的线程: Thread[第一主线程,5,main

创建第二线程

第一线程休眠

第二线程的休眠时间：0

第二线程的休眠时间：1

第二线程的休眠时间：2

第一线程退出

第二线程的休眠时间：3

第二线程的休眠时间：4

第二线程退出

这个多线程java程序为什么会最开始执行同一个线程两次

Thread t1先执行调用c.manufacture();打印"制造一台电脑" t1等待被t2唤醒wait();

Thread t2执行时调用c.transport();但是没有打印"运走一台电脑"因为"运走一台电脑"没有在c.transport();中wait()前打印,而是在c.transport();调用后打印的,所以这里没有输出.

t2执行唤醒t1 notify();t2等待被t1唤醒wait();注意这时c.transport();并没有执行完,它还在等待被t1唤醒.

Thread t1再执行调用c.manufacture();打印"制造一台电脑"唤醒t2 notify();这时c.transport();执行完了打印"运走一台电脑".然后t1等待被唤醒wait();

Thread t2执行时调用c.transport();但是没有打印"运走一台电脑"唤醒t1 notify();t2 wait();注意这时c.transport();并没有执行完,它还在等待被t1唤醒.

Thread t1执行调用c.manufacture();打印"制造一台电脑"唤醒t2 notify();这时c.transport();执行完了打印"运走一台电脑".然后t1等待被唤醒wait();

上面是造成"制造一台电脑"在开头被打印两次的原因

解决办法就是把打印"运走一台电脑"放到c.transport();函数中wait();语句前,就不会出现打印两次的情况了.

像这样:完整的程序如下:

packageexercise2;

classComputer{

privateintmfg=1;

intstack=0;

publicsynchronizedvoidmanufacture(){

try{

Thread.sleep(50);

}catch(InterruptedExceptione1){

//TODOAuto-generatedcatchblock

e1.printStackTrace();

}

System.out.println("制造一台电脑");

mfg=1;

notify();

if(mfg==1){

try{

wait();

}catch(InterruptedExceptione){

e.printStackTrace();

}

}

}

publicsynchronizedvoidtransport(){

try{

Thread.sleep(50);

}catch(InterruptedExceptione1){

//TODOAuto-generatedcatchblock

e1.printStackTrace();

}

System.out.println("运走一台电脑");//这里加上打印语句

stack+=1;

mfg=0;

notify();

if(mfg==0){

try{

wait();

}catch(InterruptedExceptione){

e.printStackTrace();

}

}

}

}

classproducerimplementsRunnable{

Computerc=null;

publicproducer(Computerc){

this.c=c;

}

@Override

publicvoidrun(){

while(true){

c.manufacture();

}

}

}

classConsumerimplementsRunnable{

Computerc=null;

publicConsumer(Computerc){

this.c=c;

}

@Override

publicvoidrun(){

while(true){

c.transport();

//System.out.println("运走一台电脑");//这里去掉打印语句移动到c.transport();函数中wait语句前

}

}

}

publicclassEx22_2{

publicstaticvoidmain(String[]args){

Computerc=newComputer();

Threadt1=newThread(newproducer(c));

Threadt2=newThread(newConsumer(c));

t1.start();

t2.start();

try{

Thread.sleep(1500);

}catch(InterruptedExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

}

t1.stop();

t2.stop();

System.out.println(c.stack);

}

}

运行结果:

制造一台电脑

运走一台电脑

制造一台电脑

运走一台电脑

制造一台电脑

运走一台电脑

制造一台电脑

运走一台电脑

制造一台电脑

运走一台电脑

制造一台电脑

运走一台电脑

制造一台电脑

运走一台电脑

制造一台电脑

运走一台电脑

制造一台电脑

运走一台电脑

制造一台电脑

运走一台电脑

制造一台电脑

运走一台电脑

制造一台电脑

运走一台电脑

制造一台电脑

运走一台电脑

制造一台电脑

运走一台电脑

制造一台电脑

14

java多线程,为什么运行起来还是单线程下面是代码

其实这个是多线程的只不过现象不明显而已，在线程启动前，main函数就已经执行完了。

以下是我的测试代码，将主函数加了一个死循环，你看一下结果

package com;

import java.lang.*;

public class Demo{

public static void main(String args[]){

new TestThread().start();

for(int i= 0; i< 10; i++){

System.out.println("main线程在运行");

while(true)

{

}

}

}

}

class TestThread extends Thread{

public void run(){

for(int i= 0; i< 10; i++){

System.out.println("TestThread在运行");

}

}

}

结果是：

main线程在运行

TestThread在运行

TestThread在运行

TestThread在运行

TestThread在运行

TestThread在运行

TestThread在运行

TestThread在运行

TestThread在运行

TestThread在运行

TestThread在运行

OK，关于java多线程为什么不断运行和这个多线程java程序为什么会最开始执行同一个线程两次的内容到此结束了，希望对大家有所帮助。