java线程中的run()方法能有几个啊？_java吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：651,070贴子：
java线程中的run()方法能有几个啊？收藏
线程这快没看懂， 我看了一下，一个new线程，一个start放一起 Thread
readThread = new Thread(this);
readThread.start();然后后面一个run()方法，里面就一个Thread.sleep(20000);最后一个处理方法，这三个完全没有什么关系，结果运行起来了，我就奇怪了，它们如何关联的,难道是哪个this？那如果在一个class中不同线程执行不同的任务，又该怎么写了？难道写run里面加if判断？？？开玩笑吧······
尚观java培训,12年办学经验,0开发基础,0费用入学,120天精通大数据开发——国内领先java培训——1周免费试听,就业协议,不就业返还学费!
只能有一个run()方法 .start();相当于执行run()
不同线程执行不同任务还要if？
一个线程就执行一个任务，你那个this是因为你那个类是implements了Runnable这个接口的。Thread有new Thread(Runnable r)这个构造方法。你要执行多个任务，就要开启多个线程。
用start()方法开启线程，系统会新建一个线程，然后运行它的run()方法。。。
class A implements Runnable{run(){A}}class B implements Runnable{run(){B}}每个类run的具体方法不一样
引用“线程这快没看懂， 我看了一下，一个new线程，一个start放一起 Thread
readThread = new Thread(this);
readThread.start();然后后面一个run()方法，里面就一个Thread.sleep(20000);最后一个处理方法，这三个完全没有什么关系，结果运行起来了，我就奇怪了，它们如何关联的,难道是哪个this？那如果在一个class中不同线程执行不同的任务，又该怎么写了？难道写run里面加if判断？？？开玩笑吧······”Thread是一个类，需要new一个对象才能使用new出来的线程。start可以使这个线程开始 放不放在一起视情况而定。一个类想要另外增加线程，必须实现Runnable接口。实现了Runnable接口，这个类就是Runnable类型的。Thread类的构造函数中有一个为public Thread(Runnable r)当一个类实现了Runnable接口时，就可以作为这个构造函数的参数。在类的内部，this关键字表示这个类的实例，也就是说，Thread thr=new Thread(this)表示用这个类本身做参数，new一个线程。run方法是新线程执行时所要执行的代码，它是Runnable接口中的方法一个类实现了Runnable接口，就必须定义run方法。至于楼主说的多线程，两个以上，编程时还真没碰到过，我也不清楚。LZ有兴趣去百度一下吧。
给个例子public class Test{
public static void main(String[] args){
//创建一个TestThread对象
TestThread tt = new TestThread();
//创建时，主线程将tt的add线程启动，add开始工作，主线程回到main方法
//主线程进入tt的mainThreadRun方法的循环。
tt.mainThreadRun();
}}/**想要多线程的类必须实现Runnable接口*/class TestThread implements Runnable{
//定义新线程
public TestThread(){
add=new Thread(this);//创建一个线程对象，this为参数
add.start();//新线程启动
/**主线程执行的代码*/
public void mainThreadRun(){
while(true){
System.out.println("这是主线程执行的代码---------");
//让主线程停止2000毫秒
//这条语句要抛出InterruptedException
Thread.sleep(2000);
} catch (InterruptedException e){
e.printStackTrace();
/**线程add执行的代码*/
public void run(){
while(add!=null){
System.out.println("这是add线程执行的代码");
//让add线程停止1000毫秒
//这条语句要抛出InterruptedException
Thread.sleep(1000);
} catch (InterruptedException e){
e.printStackTrace();
java,中公「优就业」0基础学习,小班授课,总监级导师,实战学习,推荐就业!java,中公「优就业」免费食宿,免费试学,免费重修,免费赠网课,免费入学,只等你来!
首先给大家说声抱歉,正在回家路上,没有及时回复,我现在是对串口编程,需要一边发送指令一边接收回复,用WHILE会卡住,所以考虑使用线程,同时我在提问之前也百度两天了,要不然单线程要不然多的同步问题,我问题太菜找不到答案
我现在这么考虑,一个线程起动,调用另两个线程,一个发送一个接收,也不知道可行不,等到家试试看
线程只认run方法。
登录百度帐号推荐应用Java创建线程的三种方式_Linux编程_Linux公社-Linux系统门户网站
你好，游客
Java创建线程的三种方式
来源：Linux社区&
作者：weiqubo
1)继承Thread,重写其的run方法
2)实现Runnable接口
代码如下：
创建线程的传统方式就上面两种（这里不考虑jdk1.5种线程并发库里的创建方式，后续会写到），但写的方式却是多种多样，希望初学者不要被其搞混掉
两种方式都可以创建线程，第一种方式创建比较简单，但由于java是单继承的缘故，创建出的Thread子类就无法在继承其他类；实现Runnable接口的方式可以将cpu、代码和数据分开，同时创建出的线程可以共享处理同一份资源。
记住：Thread类本身也实现了Runnable接口，因此Thread类及其子类的对象也可以作为target传递给新的线程对象。
相关资讯 & & &
& (09/25/:24)
& (02/07/:50)
& (02/01/:30)
& (04/27/:16)
& (02/01/:53)
& (01/28/:24)
　　　同意评论声明
　　　发表
尊重网上道德，遵守中华人民共和国的各项有关法律法规
承担一切因您的行为而直接或间接导致的民事或刑事法律责任
本站管理人员有权保留或删除其管辖留言中的任意内容
本站有权在网站内转载或引用您的评论
参与本评论即表明您已经阅读并接受上述条款
zhang 发表于 不也就是两种方法吗？干嘛非说是三种？不明白。还请赐教！！
(0) 匿名 发表于 不是说三种方法吗？博客分类：
最近想测试下Openfire下的最大并发数，需要开大量线程来模拟客户端。对于一个JVM实例到底能开多少个线程一直心存疑惑，所以打算实际测试下，简单google了把，找到影响线程数量的因素有下面几个：
intial java heap size
maximum java heap size
the stack size for each thread
系统最大可开线程数
测试程序如下：
import java.util.concurrent.atomic.AtomicI
public class TestThread extends Thread {
private static final AtomicInteger count = new AtomicInteger();
public static void main(String[] args) {
while (true)
(new TestThread()).start();
public void run() {
System.out.println(count.incrementAndGet());
while (true)
Thread.sleep(Integer.MAX_VALUE);
} catch (InterruptedException e) {
测试环境：
系统：Ubuntu 10.04 Linux Kernel 2.6 （32位）
测试结果：
不考虑系统限制
在创建的线程数量达到31842个时，系统中无法创建任何线程。
由上面的测试结果可以看出增大堆内存（-Xms，-Xmx）会减少可创建的线程数量，增大线程栈内存（-Xss，32位系统中此参数值最小为60K）也会减少可创建的线程数量。
结合系统限制
线程数量31842的限制是是由系统可以生成的最大线程数量决定的：/proc/sys/kernel/threads-max，可其默认值是32080。修改其值为10000：echo 10000 & /proc/sys/kernel/threads-max，修改后的测试结果如下：
这样的话，是不是意味着可以配置尽量多的线程？再做修改：echo 1000000 &
/proc/sys/kernel/threads-max，修改后的测试结果如下：
发现线程数量在达到32279以后，不再增长。查了一下，32位Linux系统可创建的最大pid数是32678，这个数值可以通过/proc/sys/kernel/pid_max来做修改（修改方法同threads-max），但是在32系统下这个值只能改小，无法更大。在threads-max一定的情况下，修改pid_max对应的测试结果如下：
在Windows上的情况应该类似，不过相比Linux，Windows上可创建的线程数量可能更少。基于线程模型的服务器总要受限于这个线程数量的限制。
JVM中可以生成的最大数量由JVM的堆内存大小、Thread的Stack内存大小、系统最大可创建的线程数量（Java线程的实现是基于底层系统的线程机制来实现的，Windows下_beginthreadex，Linux下pthread_create）三个方面影响。具体数量可以根据Java进程可以访问的最大内存（32位系统上一般2G）、堆内存、Thread的Stack内存来估算。
在64位Linux系统（CentOS 6， 3G内存）下测试，发现还有一个参数是会限制线程数量：max user process（可通过ulimit –a查看，默认值1024，通过ulimit –u可以修改此值），这个值在上面的32位Ubuntu测试环境下并无限制。
将threads-max，pid_max，max user
process，这三个参数值都修改成100000，-Xms，-Xmx尽量小（128m，64m），-Xss尽量小（64位下最小104k，可取值128k）。事先预测在这样的测试环境下，线程数量就只会受限于测试环境的内存大小（3G），可是实际的测试结果是线程数量在达到32K（32768，创建的数量最多的时候大概是33000左右）左右时JVM是抛出警告：Attempt to allocate stack guard pages failed，然后出现OutOfMemoryError无法创建本地线程。查看内存后发现还有很多空闲，所以应该不是内存容量的原因。Google此警告无果，暂时不知什么原因，有待进一步研究。
今天无意中发现文章[7]，马上试了下，果然这个因素会影响线程创建数量，按文中描述把/proc/sys/vm/max_map_count的数量翻倍，从65536变为131072，创建的线程总数量达到65000+，电脑基本要卡死（3G内存）… 简单查了下这个参数的作用，在[8]中的描述如下：
“This file contains the
maximum number of memory map areas a process may have. Memory map areas are
used as a side-effect of calling malloc, directly by mmap and mprotect, and
also when loading shared libraries.
While most applications need
less than a thousand maps, certain programs, particularly malloc debuggers, may
consume lots of them, e.g., up to one or two maps per allocation.
default value is 65536.”
OK，这个问题总算完满解决，最后总结下影响Java线程数量的因素：
Java虚拟机本身：-Xms，-Xmx，-Xss；
系统限制：
/proc/sys/kernel/pid_max，
/proc/sys/kernel/thread-max，
max_user_process（ulimit -u），
/proc/sys/vm/max_map_count。
参考资料：
浏览 26981
&&& public static void main(String[] args) {& 7.&&&&&&& while (true)& 8.&&&&&&&&&&& (new TestThread()).start();& 9.& 10.&&& }修改为
public static void main(String[] args) {
while (true)
(new TestThread()).start();
}catch(Error e){
System.exit(-1);
浏览: 175095 次
来自: 杭州
public static void main ...
关于：为什么要每个操作写一个信息，而不是在publish时写一 ...
(256 * 1024) / 64 =
很不错,学习!Java创建多线程的两种方式对比
投稿：hebedich
字体：[ ] 类型：转载 时间：
在Java中创建线程的方式有两种，第一种是直接继承Thead类，另一种是实现Runable接口。那么这两种方式孰优孰劣呢？这就是本文需要探讨的内容范畴了，看官们请仔细向下看
采用继承Thead类实现多线程：
优势：编写简单，如果需要访问当前线程，只需使用this即可，无需使用Thead.currentThread()方法。
劣势：因为这种线程类已经继承了Thead类，所以不能再继承其它类。
示例代码：
&package org.frzh.
&public class FirstThread extends Thread{
&&&& //重写run方法，run方法的方法体就是线程执行体
&&&& public void run() {
&&&&&&&& for (; i & 100; i++) {
&&&&&&&&&&&& //当线程类继承Thread类时，可以直接调用getName方法获得当前线程名
&&&&&&&&&&&& //如果想获得当前线程，直接使用this
&&&&&&&&&&&& //Thread对象的getName方法返回当前线程的名字
&&&&&&&&&&&& System.out.println(getName() + " " + i);
&&&&&&&& }
&&&& public static void main(String[] args) {
&&&&&&&& for (int i = 0; i & 100; i++) {
&&&&&&&&&&&& //调用Thead的currentThread方法获取当前线程
&&&&&&&&&&&& System.out.println(Thread.currentThread().getName() + " " +i);
&&&&&&&&&&&& if (i == 20) {
&&&&&&&&&&&&&&&& new FirstThread().start();
&&&&&&&&&&&&&&&& new FirstThread().start();
&&&&&&&&&&&& }
&&&&&&&& }
运行结果片段：
我们发现，在两个子线程中i的值并不连续，似乎与我们说的子线程直接共享数据不符。其实，在这里我们实例化了两个子线程，每个拥有自己的实例变量i。
采用实现Runable接口的多线程：
优势：线程类只是实现了Runable接口，因此还可以继承其他类；
&&&&&&&& 在这种情况下，可以使多个线程共享一个target对象，所以非常适合多个线程用来处理同一份资源的情况，从而可以将cpu、代码和数据分开，形成清晰的模型，较好的体现面向对象思想。
劣势：编程略有些复杂，如果要访问当前线程必须使用Thread.currentThread方法。
示例代码：
&package org.frzh.
&public class SecondThread implements Runnable{
&&&& @Override
&&&& public void run() {
&&&&&&&& // TODO Auto-generated method stub
&&&&&&&& for (; i & 100; i++) {
&&&&&&&&&&&& System.out.println(Thread.currentThread().getName() + " " + i);
&&&&&&&& }
&&&& public static void main(String[] args) {
&&&&&&&& for (int i = 0; i & 100; i++) {
&&&&&&&&&&&& System.out.println(Thread.currentThread().getName() + " " + i);
&&&&&&&&&&&& if (i == 20) {
&&&&&&&&&&&&&&&& SecondThread st = new SecondThread();
&&&&&&&&&&&&&&&& new Thread(st, "子线程1").start();
&&&&&&&&&&&&&&&& new Thread(st, "子线程2").start();
&&&&&&&&&&&& }
&&&&&&&& }
运行结果片段：
可以看到，此时的i值是连续变化的，因为线程1和2共享同一个target。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具博客分类：
Java提供了线程类Thread来创建多线程的程序。其实，创建线程与创建普通的类的对象的操作是一样的，而线程就是Thread类或其子类的实例对象。每个Thread对象描述了一个单独的线程。要产生一个线程，有两种方法：
◆需要从Java.lang.Thread类派生一个新的线程类，重载它的run()方法； ◆实现Runnalbe接口，重载Runnabe接口中的run()方法。
为什么Java要提供两种方法来创建线程呢？它们都有哪些区别？相比而言，哪一种方法更好呢？
在Java中，类仅支持单继承，也就是说，当定义一个新的类的时候，它只能扩展一个外部类.这样，如果创建自定义线程类的时候是通过扩展 Thread类的方法来实现的，那么这个自定义类就不能再去扩展其他的类，也就无法实现更加复杂的功能。因此，如果自定义类必须扩展其他的类，那么就可以使用实现Runnable接口的方法来定义该类为线程类，这样就可以避免Java单继承所带来的局限性。
还有一点最重要的就是使用实现Runnable接口的方式创建的线程可以处理同一资源，从而实现资源的共享.
（1）通过扩展Thread类来创建多线程
假设一个影院有三个售票口，分别用于向儿童、成人和老人售票。影院为每个窗口放有100张电影票，分别是儿童票、成人票和老人票。三个窗口需要同时卖票，而现在只有一个售票员，这个售票员就相当于一个CPU，三个窗口就相当于三个线程。通过程序来看一看是如何创建这三个线程的。
&SPAN style="FONT-SIZE: 16px"&public class MutliThreadDemo {
public static void main(String [] args){
MutliThread m1=new MutliThread("Window 1");
MutliThread m2=new MutliThread("Window 2");
MutliThread m3=new MutliThread("Window 3");
m1.start();
m2.start();
m3.start();
class MutliThread extends Thread{
private int ticket=100;
MutliThread(String name){
super(name);
public void run(){
while(ticket&0){
System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());
程序中定义一个线程类，它扩展了Thread类。利用扩展的线程类在MutliThreadDemo类的主方法中创建了三个线程对象，并通过start()方法分别将它们启动。
从结果可以看到，每个线程分别对应100张电影票，之间并无任何关系，这就说明每个线程之间是平等的，没有优先级关系，因此都有机会得到CPU的处理。但是结果显示这三个线程并不是依次交替执行，而是在三个线程同时被执行的情况下，有的线程被分配时间片的机会多，票被提前卖完，而有的线程被分配时间片的机会比较少，票迟一些卖完。
可见，利用扩展Thread类创建的多个线程，虽然执行的是相同的代码，但彼此相互独立，且各自拥有自己的资源，互不干扰。
（2）通过实现Runnable接口来创建多线程
&SPAN style="FONT-SIZE: 16px"&public class MutliThreadDemo2 {
public static void main(String [] args){
MutliThread m1=new MutliThread("Window 1");
MutliThread m2=new MutliThread("Window 2");
MutliThread m3=new MutliThread("Window 3");
Thread t1=new Thread(m1);
Thread t2=new Thread(m2);
Thread t3=new Thread(m3);
t1.start();
t2.start();
t3.start();
class MutliThread implements Runnable{
private int ticket=100;
MutliThread(String name){
this.name=
public void run(){
while(ticket&0){
System.out.println(ticket--+" is saled by "+name);
由于这三个线程也是彼此独立，各自拥有自己的资源，即100张电影票，因此程序输出的结果和（1）结果大同小异。均是各自线程对自己的100张票进行单独的处理，互不影响。
可见，只要现实的情况要求保证新建线程彼此相互独立，各自拥有资源，且互不干扰，采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。
由于这三个线程也是彼此独立，各自拥有自己的资源，即100张电影票，因此程序输出的结果和例4.2.1的结果大同小异。均是各自线程对自己的100张票进行单独的处理，互不影响。
可见，只要现实的情况要求保证新建线程彼此相互独立，各自拥有资源，且互不干扰，采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。
（3）通过实现Runnable接口来实现线程间的资源共享
现实中也存在这样的情况，比如模拟一个火车站的售票系统，假如当日从A地发往B地的火车票只有100张，且允许所有窗口卖这100张票，那么每一个窗口也相当于一个线程，但是这时和前面的例子不同之处就在于所有线程处理的资源是同一个资源，即100张车票。如果还用前面的方式来创建线程显然是无法实现的，这种情况该怎样处理呢？看下面这个程序，程序代码如下所示：
&SPAN style="FONT-SIZE: 16px"&public class MutliThreadDemo3 {
public static void main(String [] args){
MutliThread m=new MutliThread();
Thread t1=new Thread(m,"Window 1");
Thread t2=new Thread(m,"Window 2");
Thread t3=new Thread(m,"Window 3");
t1.start();
t2.start();
t3.start();
class MutliThread implements Runnable{
private int ticket=100;
public void run(){
while(ticket&0){
System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());
结果正如前面分析的那样，程序在内存中仅创建了一个资源，而新建的三个线程都是基于访问这同一资源的，并且由于每个线程上所运行的是相同的代码，因此它们执行的功能也是相同的。
可见，如果现实问题中要求必须创建多个线程来执行同一任务，而且这多个线程之间还将共享同一个资源，那么就可以使用实现Runnable接口的方式来创建多线程程序。而这一功能通过扩展Thread类是无法实现的，读者想想看，为什么？
实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者有效分离，很好地体现了面向对象程序设计的思想。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。
reference link:
浏览: 215603 次
来自: 上海
把select max(id), name from tabl ...
那你努力吧，这个总归说你的活
总的感觉少了点什么，看不出有心情、感受、景色的记录，都是一笔带 ...
自己先顶下！
hyj0903 写道sounds good初来乍到，见笑了，呵 ...}