Java基础-多线程Thread和Runnable

素颜马尾好姑娘i 2022-01-22 07:19 444阅读 0赞

### 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内部类的方式进行，例如生产者、消费者模式**

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ljeTA3MDY_size_16_color_FFFFFF_t_70][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ljeTA3MDY_size_16_color_FFFFFF_t_70]: /images/20220122/8b72929f07f14db8a17df334d5cab502.png