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();每个线程启动都对应多个对象，他们的成员变量是独立的。

2）Thread优势

1、使用线程的方法方便一些，例如：获取线程的Id（Thread.currentThread().getId()）、线程名（Thread.currentThread().getName()）、线程状态（Thread.currentThread().getState()）等

2、操作同一变量，但是线程调用run方法内容不同时，使用Thread内部类的方式进行，例如生产者、消费者模式

扫码关注一起随时随地学习！！！就在洋葱攻城狮，更多精彩，等你来！！