Java基础-多线程Thread和Runnable-蒲公英云

Java基础-多线程Thread和Runnable

1、多线程实现对多个任务进行控制

1）其中一个类Eat

public class Eat extends Thread{
public void run(){
for(int i =0;i<2;i++){
try {
Thread.sleep(1000);
System.out.println(“ eat “);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

}

2）另一个类Music

public class Music extends Thread{
public void run(){
for(int i =0;i<2;i++){
try {
Thread.sleep(1000);
System.out.println(“ music “);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

3)多线程并发执行

public static void main(String[] args) {

    Music muT = new Music();  
    Eat eatT = new Eat();  
    muT.start();  
    eatT.start();  
\}

2、继承Thread类

public class TestThread extends Thread{

/\*\*  
 \* @param ycy  
 \*/  
private String ttName;  
private int shushu = 1;  
public TestThread(String ttName) \{  
    super();  
    this.ttName = ttName;  
\}  
@Override  
public void run() \{  
    // TODO Auto-generated method stub  
    while(shushu<=10)\{  
        System.out.println(ttName+" 对应的数为： "+shushu+"; ");  
        shushu++;  
    \}  
\}  
//并发进行两个进程，每个人都数数10；  
public static void main(String\[\] args) \{  
    // TODO Auto-generated method stub  
    TestThread tt1 = new TestThread("1号线程");  
    TestThread tt2 = new TestThread("2号线程");  
    tt1.start();  
    tt2.start();  
\}

}

3、Runnable

public class TestRun implements Runnable {

/\*\*  
 \* @param args  
 \*/  
private String ttName;  
private int shushu = 1;  
public TestRun(String ttName) \{  
    super();  
    this.ttName = ttName;  
\}  
public void run() \{  
    // TODO Auto-generated method stub  
    while(shushu<=10)\{  
        System.out.println(ttName+" 对应的数数1为： "+shushu+"; ");  
        shushu++;  
    \}  
\}  
//并发进行两个进程，每个人都数数10；  
public static void main(String\[\] args) \{  
    // TODO Auto-generated method stub  
    TestRun tr1 = new TestRun("一号线程");  
    TestRun tr2 = new TestRun("二号线程");  
    Thread t11 = new Thread(tr1);  
    Thread t22 = new Thread(tr2);  
    t11.start();  
    t22.start();
\}

}

4、多个线程同步

public class TestRun implements Runnable {

/\*\*  
 \* @param args  
 \*/  
private String ttName;  
private int shushu = 1;  
public TestRun(String ttName) \{  
    super();  
    this.ttName = ttName;  
\}  
public synchronized void run() \{//synchronized线程同步，如果不加，出现重复和混乱数据  
    // TODO Auto-generated method stub  
    while(shushu<=10)\{  
        System.out.println(ttName+" 对应的数数1为： "+shushu+"; ");  
        shushu++;  
    \}  
\}  
//并发进行两个进程，每个人都数数10；  
public static void main(String\[\] args) \{
    TestRun tr3 = new TestRun("超级线程2");  
    Thread t1 = new Thread(tr3);  
    Thread t2 = new Thread(tr3);  
    Thread t3 = new Thread(tr3);  
    t1.start();  
    t2.start();  
    t3.start();      
\}

}

两种方式的区别和联系

1）Runnable相对优势：

java的单继承，当继承了Thread类，则不能继承其他类，而实现Runnable接口可以
实现Runnable接口的线程类的多个线程，可以访问同一变量，而Thread则不能（多窗口买票问题）

原因：两种方式启动方式不同：

Runnable线程类是实例化一个对象o之后，通过多次new Thread（o）.start();启动多个线程，而这几个线程属于一个对象，对象的成员变量是同一个。
Thread线程类启动多个线程需要 new MyThread().start();每个线程启动都对应多个对象，他们的成员变量是独立的。