实现多线程的两种方式：
java中主要提供两种方式实现线程：分别为继承Thead类和实现Runnable接口。
1． 通过继承Thread类，重写Thread的run()方法，将线程运行的逻辑放在其中
2． 通过实现Runnable接口，实例化Thread类
一、通过继承Thread类实现多线程
class MyThread extends Thread{
String name = null;
int ticket = 0;
public MyThread(String name){
this.name = name;
}
public synchronized void run(){
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()+this.name+" ticket:"+ticket++);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}public static void main(String[] args) {
MyThread mThread1 = new MyThread("线程一");
MyThread mThread2 = new MyThread("线程二");
MyThread mThread3 = new MyThread("线程三");
mThread1.start();
mThread2.start();
mThread3.start();
}运行结果如下：
Thread-1线程二 ticket:0
Thread-0线程一 ticket:0
Thread-2线程三 ticket:0
Thread-1线程二 ticket:1
Thread-0线程一 ticket:1
Thread-2线程三 ticket:1
Thread-1线程二 ticket:2
Thread-2线程三 ticket:2
Thread-0线程一 ticket:2
Thread-1线程二 ticket:3
Thread-2线程三 ticket:3
Thread-0线程一 ticket:3
Thread-1线程二 ticket:4
Thread-2线程三 ticket:4
Thread-0线程一 ticket:4二、通过继承Runnable接口实现多线程
class RunThread implements Runnable{
int Counter = 0;
@Override
public synchronized void run() {
for(int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+"count:"+Counter++);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}public static void main(String[] args) {
RunThread rThread = new RunThread();
Thread t1 = new Thread(rThread,"线程一");
Thread t2 = new Thread(rThread,"线程二");
Thread t3 = new Thread(rThread,"线程三");
t1.start();
t2.start();
t3.start();
}输出结果：
线程一count:0
线程一count:1
线程一count:2
线程一count:3
线程一count:4
线程二count:5
线程二count:6
线程二count:7
线程二count:8
线程二count:9
线程三count:10
线程三count:11
线程三count:12
线程三count:13
线程三count:14线程的生命周期：
线程具有生命周期，其中包含7种状态，分别为出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态。
下面对线程生命周期中的 7 种状态做说明。
- 出生状态：用户在创建线程时所处的状态，在用户使用该线程实例调用 start() 方法之前，线程都处于出生状态。
- 就绪状态：也称可执行状态，当用户调用 start() 方法之后，线程处于就绪状态。
- 运行状态：当线程得到系统资源后进入运行状态。
- 等待状态：当处于运行状态下的线程调用 Thread 类的 wait() 方法时，该线程就会进入等待状态。进入等待状态的线程必须调用 Thread 类的 notify() 方法才能被唤醒。notifyAll() 方法是将所有处于等待状态下的线程唤醒。
- 休眠状态：当线程调用 Thread 类中的 sleep() 方法时，则会进入休眠状态。
- 阻塞状态：如果一个线程在运行状态下发出输入/输出请求，该线程将进入阻塞状态，在其等待输入/输出结束时，线程进入就绪状态。对阻塞的线程来说，即使系统资源关闭，线程依然不能回到运行状态。
- 死亡状态：当线程的 run() 方法执行完毕，线程进入死亡状态。
根据图 1 所示，可以总结出使线程处于就绪状态有如下几种方法。
- 调用 sleep() 方法。
- 调用 wait() 方法。
- 等待输入和输出完成。
当线程处于就绪状态后，可以用如下几种方法使线程再次进入运行状态。
- 线程调用 notify() 方法。
- 线程调用 notifyAll() 方法。
- 线程调用 intermpt() 方法。
- 线程的休眠时间结束。
- 输入或者输出结束。
操作线程的方法：
一种能控制线程行为的方法是调用sleep()方法，sleep方法需要一个参数用于指定该线程休眠的时间，该时间以毫秒为单位。
sleep语法：
package Thread1;
class MyThread implements Runnable{ // 实现Runnable接口
public void run(){ // 覆写run()方法
for(int i=0;i<50;i++){
try{
Thread.sleep(500) ; // 线程休眠
}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()
+ "运行，i = " + i) ; // 取得当前线程的名字
}
}
};
public class demo1{
public static void main(String args[]){
MyThread mt = new MyThread() ; // 实例化Runnable子类对象
Thread t = new Thread(mt,"线程"); // 实例化Thread对象
t.start() ; // 启动线程
}
};线程的加入：
package Thread1;
class MyThread implements Runnable{ // 实现Runnable接口
public void run(){ // 覆写run()方法
for(int i=0;i<50;i++){
System.out.println(Thread.currentThread().getName()
+ "运行，i = " + i) ; // 取得当前线程的名字
}
}
};
public class demo1{
public static void main(String args[]){
MyThread mt = new MyThread() ; // 实例化Runnable子类对象
Thread t = new Thread(mt,"线程"); // 实例化Thread对象
t.start() ; // 启动线程
for(int i=0;i<50;i++){
if(i>10){
try{
t.join() ; // 线程强制运行
}catch(InterruptedException e){}
}
System.out.println("Main线程运行 --> " + i) ;
}
}
};当某个线程使用join()方法加入到另外一个线程时，另一个线程会等待该线程执行结束后继续执行。
线程的中断：
一个线程可以被另一个线程中断其操作的状态，使用 interrupt（）方法完成。
package Thread1;
class MyThread implements Runnable{ // 实现Runnable接口
public void run(){ // 覆写run()方法
System.out.println("1、进入run()方法") ;
try{
Thread.sleep(10000) ; // 线程休眠10秒
System.out.println("2、已经完成了休眠") ;
}catch(InterruptedException e){
System.out.println("3、休眠被终止") ;
return ; // 返回调用处
}
System.out.println("4、run()方法正常结束") ;
}
};
public class demo1{
public static void main(String args[]){
MyThread mt = new MyThread() ; // 实例化Runnable子类对象
Thread t = new Thread(mt,"线程"); // 实例化Thread对象
t.start() ; // 启动线程
try{
Thread.sleep(2000) ; // 线程休眠2秒
}catch(InterruptedException e){
System.out.println("3、休眠被终止") ;
}
t.interrupt() ; // 中断线程执行
}
};
线程的优先级：
优先级分为最低，最高，普通三个（Thread.MIN_PRIORITY，Thread.MAX_PRIORITY，Thread.NORM_PRIORITY），
package Thread1;
class MyThread implements Runnable{ // 实现Runnable接口
public void run(){ // 覆写run()方法
for(int i=0;i<5;i++){
try{
Thread.sleep(500) ; // 线程休眠
}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()
+ "运行，i = " + i) ; // 取得当前线程的名字
}
}
};
public class demo1{
public static void main(String args[]){
Thread t1 = new Thread(new MyThread(),"线程A") ; // 实例化线程对象
Thread t2 = new Thread(new MyThread(),"线程B") ; // 实例化线程对象
Thread t3 = new Thread(new MyThread(),"线程C") ; // 实例化线程对象
t1.setPriority(Thread.MIN_PRIORITY) ; // 优先级最低
t2.setPriority(Thread.MAX_PRIORITY) ; // 优先级最低
t3.setPriority(Thread.NORM_PRIORITY) ; // 优先级最低
t1.start() ; // 启动线程
t2.start() ; // 启动线程
t3.start() ; // 启动线程
}
};运行结果：
线程B运行，i = 0
线程C运行，i = 0
线程A运行，i = 0
线程B运行，i = 1
线程C运行，i = 1
线程A运行，i = 1
线程B运行，i = 2
线程A运行，i = 2
线程C运行，i = 2
线程B运行，i = 3
线程C运行，i = 3
线程A运行，i = 3
线程B运行，i = 4
线程C运行，i = 4
线程A运行，i = 4