java多线程返回值

⑴ java多线程的几种写法

有三种：
(1)继承类，重写run函数
创建：
class xx extends Thread{
public void run(){
Thread.sleep(1000) //线程休眠1000毫秒，sleep使线程进入Block状态，并释放资源
}}
开启线程：
对象.start() //启动线程，run函数运行
(2)实现Runnable接口，重写run函数
开启线程：
Thread t = new Thread(对象) //创建线程对象
t.start()
(3)实现Callable接口，重写call函数
Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。
Callable和Runnable有几点不同:
①Callable规定的方法是call()，而Runnable规定的方法是run().
②Callable的任务执行后可返回值，而Runnable的任务是不能返回值的
③call()方法可抛出异常，而run()方法是不能抛出异常的。
④运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。它提供了检查计算是否完成的方法,以等
待计算的完成,并检索计算的结果.通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果

⑵ 各位大拿 java 多线程 同时调用单例对象带有返回值的方法 会不出线程之间出错

多线程同时调用单例对象的方法，如果你方法里用到了共享变量(共享变量就是类属性)， 而共享变量又没有做同步(synchronized)， 那就会出你说的问题了。 去掉共享变量，只在方法里使用私有变量，就没问题了。
-- 注意，如果共享变量是只读的，也不会出问题。

⑶ java多线程问题 跳过run方法里面的if执行

多线程

35. 并行和并发有什么区别？

并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。

在一台处理器上“同时”处理多个任务，在多台处理器上同时处理多个任务。如hadoop分布式集群。

所以并发编程的目标是充分的利用处理器的每一个核，以达到最高的处理性能。

36. 线程和进程的区别？

简而言之，进程是程序运行和资源分配的基本单位，一个程序至少有一个进程，一个进程至少有一个线程。进程在执行过程中拥有独立的握脊内存单元，而多个线程共享内存资源，减少切换次数，从而效率更高。线程是进程的一个实体，是cpu调度和分派的基本单位，是比程序更小的能独立运行的基本单位。同一进程中的多个线程之间可以并发执行。

37. 守护线程是什么？

守护线程(即daemon thread)，是个服务线程，准确地来说就是服务其他的线程。

38. 创建线程有哪几种方式？

①. 继承Thread类创建线程类

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

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

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

②. 通过Runnable接口创建线程类

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

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

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

③. 通过Callable和Future创建线程

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

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

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

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

39. 说一下 runnable 和 callable 有什么区别？

有点深的问题了，也看出一个Java程序员学习知识的广度。

Runnable接口中的run方法的返回值是void，它做的事情只是纯粹地去执行run方法中的代码而已；

Callable接口中的call方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。

40. 线程有哪些状态？

线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。

创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。

就绪状态。当调用了线程对象的start方法之后，该线段侍渗程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在谈册线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。

运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。

阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend，wait等方法都可以导致线程阻塞。

死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪

41. sleep 和 wait 有什么区别？

sleep：方法是线程类(Thread)的静态方法，让调用线程进入睡眠状态，让出执行机会给其他线程，等到休眠时间结束后，线程进入就绪状态和其他线程一起竞争cpu的执行时间。因为sleep 是static静态的方法，他不能改变对象的机锁，当一个synchronized块中调用了sleep 方法，线程虽然进入休眠，但是对象的机锁没有被释放，其他线程依然无法访问这个对象。

wait：wait是Object类的方法，当一个线程执行到wait方法时，它就进入到一个和该对象相关的等待池，同时释放对象的机锁，使得其他线程能够访问，可以通过notify，notifyAll方法来唤醒等待的线程

42. notify和 notifyAll有什么区别？

如果线程调用了对象的 wait方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。

当有线程调用了对象的 notifyAll方法(唤醒所有 wait 线程)或 notify方法(只随机唤醒一个 wait 线程)，被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争。

优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用 wait方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。

43. 线程的 run和 start有什么区别？

每个线程都是通过某个特定Thread对象所对应的方法run来完成其操作的，方法run称为线程体。通过调用Thread类的start方法来启动一个线程。

start方法来启动一个线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码；这时此线程是处于就绪状态， 并没有运行。然后通过此Thread类调用方法run来完成其运行状态， 这里方法run称为线程体，它包含了要执行的这个线程的内容， Run方法运行结束， 此线程终止。然后CPU再调度其它线程。

run方法是在本线程里的，只是线程里的一个函数,而不是多线程的。 如果直接调用run,其实就相当于是调用了一个普通函数而已，直接待用run方法必须等待run方法执行完毕才能执行下面的代码，所以执行路径还是只有一条，根本就没有线程的特征，所以在多线程执行时要使用start方法而不是run方法。

44. 创建线程池有哪几种方式？

①. newFixedThreadPool(int nThreads)

创建一个固定长度的线程池，每当提交一个任务就创建一个线程，直到达到线程池的最大数量，这时线程规模将不再变化，当线程发生未预期的错误而结束时，线程池会补充一个新的线程。

②. newCachedThreadPool

创建一个可缓存的线程池，如果线程池的规模超过了处理需求，将自动回收空闲线程，而当需求增加时，则可以自动添加新线程，线程池的规模不存在任何限制。

③. newSingleThreadExecutor

这是一个单线程的Executor，它创建单个工作线程来执行任务，如果这个线程异常结束，会创建一个新的来替代它；它的特点是能确保依照任务在队列中的顺序来串行执行。

④. newScheledThreadPool(int corePoolSize)

创建了一个固定长度的线程池，而且以延迟或定时的方式来执行任务，类似于Timer。

45. 线程池都有哪些状态？

线程池有5种状态：Running、ShutDown、Stop、Tidying、Terminated

⑷ java大数据 多线程写文件

1、采用public static的变量存储这一数值，每个线程都往这一共有静态变量里写入已复制大内小。 2、采用Callable方式实现多线程，容将结果作为返回值返回到主线程。这一方法只能在所有子线程都完成之后才能通过future获取。

⑸ java 线程中的值如何返回

如果是java5的话，那么Java5新增了Callable接口获得线程的返回值，用法如下

packagecom.ronniewang;


importjava.util.concurrent.Callable;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.Future;


{


privatestaticfinalintSLEEP_MILLS=3000;


privatestaticfinalintSECOND_MILLS=1000;


privatestaticintsleepSeconds=SLEEP_MILLS/SECOND_MILLS;


=Executors.newCachedThreadPool();


/**
*在创建多线程程序的时候，我们常实现Runnable接口，Runnable没有返回值，要想获得返回值，Java5提供了一个新的接口Callable
*/
publicstaticvoidmain(String[]args){


newGetReturnValueFromCallable().testCallable();
}


privatevoidtestCallable(){


/**
*Callable需要实现的是call()方法，而不是run()方法，返回值的类型有Callable的类型参数指定，
*Callable只能由ExecutorService.submit()执行，正常结束后将返回一个future对象
*/
Future<String>future=executorService.submit(newCallable<String>(){


publicStringcall()throwsException{


Thread.sleep(SLEEP_MILLS);
return"Ifromcallable";
}
});


while(true){
/**
*获得future对象之前可以使用isDone()方法检测future是否完成，完成后可以调用get()方法获得future的值，
*如果直接调用get()方法，get()方法将阻塞值线程结束
*/
if(future.isDone()){
try{
System.out.println(future.get());
break;
}catch(InterruptedExceptione){
//ignored
}catch(ExecutionExceptione){
//ignored
}
}
else{
try{
System.out.println("after"+sleepSeconds--+"seconds,wewillgetfuture");
Thread.sleep(SECOND_MILLS);
}catch(InterruptedExceptione){
//ignored
}
}
}
}
}
packagecom.ronniewang;


importjava.util.concurrent.Callable;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.Future;


{


privatestaticfinalintSLEEP_MILLS=3000;


privatestaticfinalintSECOND_MILLS=1000;


privatestaticintsleepSeconds=SLEEP_MILLS/SECOND_MILLS;


=Executors.newCachedThreadPool();


/**
*在创建多线程程序的时候，我们常实现Runnable接口，Runnable没有返回值，要想获得返回值，Java5提供了一个新的接口Callable
*/
publicstaticvoidmain(String[]args){


newGetReturnValueFromCallable().testCallable();
}


privatevoidtestCallable(){


/**
*Callable需要实现的是call()方法，而不是run()方法，返回值的类型有Callable的类型参数指定，
*Callable只能由ExecutorService.submit()执行，正常结束后将返回一个future对象
*/
Future<String>future=executorService.submit(newCallable<String>(){


publicStringcall()throwsException{


Thread.sleep(SLEEP_MILLS);
return"Ifromcallable";
}
});


while(true){
/**
*获得future对象之前可以使用isDone()方法检测future是否完成，完成后可以调用get()方法获得future的值，
*如果直接调用get()方法，get()方法将阻塞值线程结束
*/
if(future.isDone()){
try{
System.out.println(future.get());
break;
}catch(InterruptedExceptione){
//ignored
}catch(ExecutionExceptione){
//ignored
}
}
else{
try{
System.out.println("after"+sleepSeconds--+"seconds,wewillgetfuture");
Thread.sleep(SECOND_MILLS);
}catch(InterruptedExceptione){
//ignored
}
}
}
}
}

输出结果：
after3seconds,wewillgetfuture
after2seconds,wewillgetfuture
after1seconds,wewillgetfuture
Ifromcallable

⑹ 使用java多线程打印0到1000输出且不重复，如何实现

这其实是一个多线程，资源共享的问题。实现Runnable接口就可以了。

截图是一个多线程资源共享回的例子，每个线答程可以互相知道ticket的值，这样就不会重复。

把ticket初始为0，每个线程打印出ticket的值，打完+1。下一个线程再打印ticket就是+1之后的值。然后再判断ticket的值，>=1000的时候停止线程。

详细的你可以看看：

java多线程总结 - Rollen Holt - 博客园

http://www.cnblogs.com/rollenholt/archive/2011/08/28/2156357.html

完全可以解决你的需求

⑺ JAVA多线程有哪几种实现方式

JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。

1、继承Thread类实现多线程
继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：

[java]view plain

• {

• publicvoidrun(){

• System.out.println("MyThread.run()");

• }

• }

• 在合适的地方启动线程如下：



[java]view plain

• MyThreadmyThread1=newMyThread();

• MyThreadmyThread2=newMyThread();

• myThread1.start();

• myThread2.start();



• 2、实现Runnable接口方式实现多线程


• 如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口，如下：



[java]view plain

• {

• publicvoidrun(){

• System.out.println("MyThread.run()");

• }

• }

• 为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：



[java]view plain

• MyThreadmyThread=newMyThread();

• Threadthread=newThread(myThread);

• thread.start();

• 事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：



[java]view plain

• publicvoidrun(){

• if(target!=null){

• target.run();

• }

• }



• 3、使用ExecutorService、Callable、Future实现有返回结果的多线程


• ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。想要详细了解Executor框架的可以访问http://www.javaeye.com/topic/366591 ，这里面对该框架做了很详细的解释。返回结果的线程是在JDK1.5中引入的新特征，确实很实用，有了这种特征我就不需要再为了得到返回值而大费周折了，而且即便实现了也可能漏洞百出。


• 可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子，在JDK1.5下验证过没问题可以直接使用。

⑻ JAVA多线程问题，想让每次线程运行后都能返回值给成员变量，要如何修改

把a定义成公共的，在thread里i++时，a也跟着++就行，，不过你的代码怎么构造出了好几个线程？？？如果这几个线程公用一个i变量，那么Thread1需要实现Runnable接口，而不是继承Thread类
publicclassXianChengNew{
	publicstaticinta=0;

	publicstaticvoidmain(String[]args){
		Thread1t1=null;
		t1=newThread1(a);
		t1.start();
		booleanflag=true;
		while(flag){
			if(!t1.isAlive()){
				flag=false;
			}
		}
		System.out.println("Maina="+a);
	}
}

classThread1extendsThread{
	privateinti=0;

	publicThread1(inti){
		super();
		this.i=i;
	}

	@Override
	publicvoidrun(){
		//super.run();
		//for(ints=0;s<100;s++){
		add();
		//}
	}

	synchronizedvoidadd(){
		for(intc=0;c<5;c++){
			i++;
			XianChengNew.a++;
			System.out.println("i="+i);
			System.out.println("a="+XianChengNew.a);
		}
	}
}

⑼ 多线程有哪些实现方式

java多线程的几种实现方式：闭耐困
1.继承Thread类，重写run方法
2.实现Runnable接口，重写轿念run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target
3.通过Callable和FutureTask创建线程
4.通过线程池创建线程 （上一篇已经讲过了）
前面两种可以归结为一类：无返回值，原因很简单，通过重写run方法，run方式的返亩判回值是void，所以没有办法返回结果
后面两种可以归结成一类：有返回值，通过Callable接口，就要实现call方法，这个方法的返回值是Object，所以返回的结果可以放在Object对象中

⑽ java多线程编程代码如下，输出结果如下:

首先，你同步的是具体的某个Test实例， 对于那个实例来说，实际上只有一个线程访问了那个代码块，但是sum和other却是多个线程同时去进行访问，实际上这是不安全的，如果你想实现每次都输出10000的效果，那么正确的应该是在Test.class上加锁，而不是获取Test实例的锁，修改后的代码如下：

publicclassTestextendsThread{

publicstaticintsum=10000;

publicstaticintother=0;

publicvoidgetMoney(){
synchronized(Test.class){

System.out.println(Thread.currentThread().getName()+"开始执行");
sum=sum-100;

System.out.println("sum-100");

other=other+100;

System.out.println("other+100");

System.out.println(sum+other);
System.out.println(Thread.currentThread().getName()+"执行完成");
}

}

publicvoidrun(){

getMoney();

}

publicstaticvoidmain(String[]agrs){

Threadt[]=newThread[10];

for(inti=0;i<=9;i++){

t[i]=newTest();

t[i].start();

}

}

}

// 上面代码能得到你的结果