javarunnablethread

‘壹’ java中线程的几种可用状态有哪些请大家解释一下。

线程在执行过程中，可以处于下面几种状态：
1、就绪(Runnable):线程准备运行，不一定立马就能开始执行。
2、运行中(Running)：进程正在执行线程的代码。
3、等待中(Waiting):线程处于阻塞的状态，等待外部的处理结束。
4、睡眠中(Sleeping)：线程被强制睡眠。
5、I/O阻塞(BlockedonI/O)：等待I/O操作完成。
6、同步阻塞(BlockedonSynchronization)：等待获取锁。
7、死亡(Dead)：线程完成了执行。

‘贰’ Java中Runnable和Thread的区别

线程的起动并不是简单的调用了你的RUN方法,而是由一个线程调度器来分别调用你的所有线程的RUN方法,
我们普通的RUN方法如果没有执行完是不会返回的,也就是会一直执行下去,这样RUN方法下面的方法就不可能会执行了,可是线程里的RUN方法却不一样,它只有一定的CPU时间,执行过后就给别的线程了,这样反复的把CPU的时间切来切去,因为切换的速度很快,所以我们就感觉是很多线程在同时运行一样.

你简单的调用run方法是没有这样效果的,所以你必须调用Thread类的start方法来启动你的线程.所以你启动线程有两种方法
一是写一个类继承自Thread类,然后重写里面的run方法,用start方法启动线程
二是写一个类实现Runnable接口,实现里面的run方法,用newThread(Runnabletarget).start()方法来启动

这两种方法都必须实现RUN方法,这样线程起动的时候,线程管理器好去调用你的RUN方法.

你的TestThread没有继承自Thread类,怎么可能会有start方法呢?


在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；
Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的
run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限，
下面看例子：
packageorg.thread.demo;
classMyThreadextendsThread{
privateStringname;
publicMyThread(Stringname){
super();
this.name=name;
}
publicvoidrun(){
for(inti=0;i<10;i++){
System.out.println("线程开始："+this.name+",i="+i);
}
}
}
packageorg.thread.demo;
publicclassThreadDemo01{
publicstaticvoidmain(String[]args){
MyThreadmt1=newMyThread("线程a");
MyThreadmt2=newMyThread("线程b");
//thread1，thread2，按顺序进行
mt1.run();
mt2.run();
}
}
但是，此时结果很有规律，先第一个对象执行，然后第二个对象执行，并没有相互运行。在JDK的文档中可以发现，一旦调用start()方法，则会通过JVM找到run()方法。下面启动
start()方法启动线程：
packageorg.thread.demo;
publicclassThreadDemo01{
publicstaticvoidmain(String[]args){
MyThreadmt1=newMyThread("线程a");
MyThreadmt2=newMyThread("线程b");
//乱序进行
mt1.start();
mt2.start();
}
};
这样程序可以正常完成交互式运行。那么为啥非要使用start()方法启动多线程呢？
在JDK的安装路径下，src.zip是全部的java源程序，通过此代码找到Thread中的start()方法的定义，可以发现此方法中使用了privatenativevoidstart0();其中native关键字表示可以调用操作系统的底层函数，那么这样的技术成为JNI技术（javaNativeInterface）
·Runnable接口
在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口完成。
publicinterfaceRunnable{
publicvoidrun();
}
例子：
packageorg.runnable.demo;
{
privateStringname;
publicMyThread(Stringname){
this.name=name;
}
publicvoidrun(){
for(inti=0;i<100;i++){
System.out.println("线程开始："+this.name+",i="+i);
}
}
};


但是在使用Runnable定义的子类中没有start()方法，只有Thread类中才有。此时观察Thread类，有一个构造方法：publicThread(Runnabletarget)
此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多
线程。（start()可以协调系统的资源）:
packageorg.runnable.demo;
importorg.runnable.demo.MyThread;
publicclassThreadDemo01{
publicstaticvoidmain(String[]args){
MyThreadmt1=newMyThread("线程a");
MyThreadmt2=newMyThread("线程b");
newThread(mt1).start();
newThread(mt2).start();
}
}
·两种实现方式的区别和联系：
在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比
继承Thread类有如下好处：
->避免点继承的局限，一个类可以继承多个接口。
->适合于资源的共享
以卖票程序为例，通过Thread类完成：
packageorg.demo.dff;
classMyThreadextendsThread{
privateintticket=10;
publicvoidrun(){
for(inti=0;i<20;i++){
if(this.ticket>0){
System.out.println("卖票：ticket"+this.ticket--);
}
}
}
};
下面通过三个线程对象，同时卖票：
packageorg.demo.dff;
publicclassThreadTicket{
publicstaticvoidmain(String[]args){
MyThreadmt1=newMyThread();
MyThreadmt2=newMyThread();
MyThreadmt3=newMyThread();
mt1.start();//每个线程都各卖了10张，共卖了30张票
mt2.start();//但实际只有10张票，每个线程都卖自己的票
mt3.start();//没有达到资源共享
}
}
如果用Runnable就可以实现资源共享，下面看例子：
packageorg.demo.runnable;
{
privateintticket=10;
publicvoidrun(){
for(inti=0;i<20;i++){
if(this.ticket>0){
System.out.println("卖票：ticket"+this.ticket--);
}
}
}
}
packageorg.demo.runnable;
publicclassRunnableTicket{
publicstaticvoidmain(String[]args){
MyThreadmt=newMyThread();
newThread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一
newThread(mt).start();//个实例化对象mt，就会出现异常
newThread(mt).start();
}
};
虽然现在程序中有三个线程，但是一共卖了10张票，也就是说使用Runnable实现多线程可以达到资源共享目的。
Runnable接口和Thread之间的联系：

发现Thread类也是Runnable接口的子类。

‘叁’ 在Java 中多线程的实现方法有哪些，如何使用～～～～～～～～～～～～～～～～～～急

1、 认识Thread和Runnable

Java中实现多线程有两种途径：继承Thread类或者实现Runnable接口。Runnable是接口，建议用接口的方式生成线程，因为接口可以实现多继承，况且Runnable只有一个run方法，很适合继承。在使用Thread的时候只需继承Thread，并且new一个实例出来，调用start()方法即可以启动一个线程。

Thread Test = new Thread();

Test.start();

在使用Runnable的时候需要先new一个实现Runnable的实例，之后启动Thread即可。

Test impelements Runnable;

Test t = new Test();

Thread test = new Thread(t);

test.start();

总结：Thread和Runnable是实现java多线程的2种方式，runable是接口，thread是类，建议使用runable实现java多线程，不管如何，最终都需要通过thread.start()来使线程处于可运行状态。

2、 认识Thread的start和run

1） start：

用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到spu时间片，就开始执行run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。

2） run：

run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。

3、 线程状态说明

线程状态从大的方面来说，可归结为：初始状态、可运行状态、不可运行状态和消亡状态，具体可细分为上图所示7个状态，说明如下：

1） 线程的实现有两种方式，一是继承Thread类，二是实现Runnable接口，但不管怎样，当我们new了thread实例后，线程就进入了初始状态；

2） 当该对象调用了start()方法，就进入可运行状态；

3） 进入可运行状态后，当该对象被操作系统选中，获得CPU时间片就会进入运行状态；

4） 进入运行状态后case就比较多，大致有如下情形：

·run()方法或main()方法结束后，线程就进入终止状态；

·当线程调用了自身的sleep()方法或其他线程的join()方法，就会进入阻塞状态(该状态既停止当前线程，但并不释放所占有的资源)。当sleep()结束或join()结束后，该线程进入可运行状态，继续等待OS分配时间片；

·当线程刚进入可运行状态(注意，还没运行)，发现将要调用的资源被锁牢(synchroniza,lock)，将会立即进入锁池状态，等待获取锁标记(这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于队列状态，既先到先得)，一旦线程获得锁标记后，就转入可运行状态，等待OS分配CPU时间片；

·当线程调用wait()方法后会进入等待队列(进入这个状态会释放所占有的所有资源，与阻塞状态不同)，进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒(由于notify()只是唤醒一个线程，但我们由不能确定具体唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用notifyAll()方法，唤醒有所线程)，线程被唤醒后会进入锁池，等待获取锁标记。

·当线程调用stop方法，即可使线程进入消亡状态，但是由于stop方法是不安全的，不鼓励使用，大家可以通过run方法里的条件变通实现线程的stop。

‘肆’ java创建线程的几种方式，了解一下

第一种方式：使用Runnable接口创建线程

第二种方式：直接继承Thread类创建对象

使用Runnable接口创建线程

1.可以将CPU，代码和数据分开，形成清晰的模型

2.线程体run()方法所在的类可以从其它类中继承一些有用的属性和方法

3.有利于保持程序的设计风格一致

直接继承Thread类创建对象

1.Thread子类无法再从其它类继承（java语言单继承）。

2.编写简单，run()方法的当前对象就是线程对象，可直接操作。

在实际应用中，几乎都采取第一种方式

‘伍’ java 多线程 继承Thread和实现Runnable的区别

Java中线程的创建有两种方式：

1、 通过继承Thread类，重写Thread的run()方法，将线程运行的逻辑放在其中

2、 通过实现Runnable接口，实例化Thread类

Runnable
接口只有一个方法 run()，我们声明自己的类实现 Runnable
接口并提供这一方法，将我们的线程代码写入其中，就完成了这一部分的任务。但是 Runnable 接口并没有任何对线程的支持，我们还必须创建
Thread 类的实例，这一点通过 Thread 类的构造函数public Thread(Runnable target);来实现。

3、继承Thread实现的模式是 定义多个线程,各自完成各自的任务.

4、实现Runnable实现的模式是 定义多个线程,实现一个任务.

总结：一个是多个线程分别完成自己的任务，一个是多个线程共同完成一个任务。其实，在实现一个任务用多个线程来做也可以用继承Thread类来实现，只是比较麻烦，一般我们用实现Runnable接口来实现。