1.多线程简介

image.png

image.png

操作系统的最小单元：进程
进程在运行的时候： 保证至少有一条线程或多条线程在进行操作
进程内部 包含 线程

Java中：开启一个线程 将main方法入栈
一个线程相当于一个栈 多个线程相当于多个栈

package com.lty.yu;

public class Test05 {
    //线程
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        for(int i = 0 ;i<100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }

    }

}

2.实现多线程的俩种方式

image.png

image.png

3.线程与进程的五种状态

image.png

（1）New(新建状态)

start（）； 新开辟一个线程

（2）Runnable(可运行状态)

可以等待被运行

（3）Running（运行状态）

正在执行

（4）Block（阻塞状态）

sleep() ； 先别执行我，执行别人

（5）Dead（死亡状态）

所有方法都被执行完毕包括main（）；方法，再栈中依次出栈

4.实现多线程的俩种方式--------代码讲解部分

package com.lty.yu;

public class Test05 {
    //线程
    public static void main(String[] args) {//名字为main 的线程或栈是java 虚拟机自动帮助我们完成的
        // TODO Auto-generated method stub
        new Test05().method2();
        //start 1.开辟新的栈将run方法入栈   2.执行run方法 ------------》开辟新的线程
        new ThreadTest05().start();//默认 Thread-0
        RunnableTest rt1 = new RunnableTest();
        Thread t = new Thread(rt1);
        t.start();
        for(int i = 0 ;i<100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        /*
         * 想实现多线程,有俩种方式：
         * 1.继承Thread类
         * 使用方法：a.一个类继承Thread类  b.重写run方法 c.调用start方法 激活新的线程
         * 2.实现Runnable接口
         * 使用方法：a.一个类继承Runnable接口 b.重写run方法 
         * c.通过线程 将Runnable对象作为成员变量输入 (相当于重写run方法) 
         * d.调用线程对象的 start 方法激活新线程
         */
        

    }
    
    public void method2() {
        
        System.out.println("method2");
    }

}

package com.lty.yu;

public class ThreadTest05 extends Thread{
    
    public void run() {//thread 类中有一个方法  空参run方法
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    public void method1() {
        System.out.println("threadtest05method1");
    }
}

package com.lty.yu;
        //实现接口
public class RunnableTest implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
    }

}

5.线程小练习

package com.lty.yu;

public class Test06 {
    public static void main(String[] args) {
        //1.通过用Runnable 实现 1~100的输出 俩个线程同时输出
        Run R1 = new Run();
        Thread t1 = new Thread(R1);
        t1.setName("Runnable线程1");
        Thread t2 = new Thread(R1);
        t2.setName("Runnable线程2");
        t1.start();
        t2.start();
        
        //2.用继承Thread类的方法   实现1~100的输出 俩个线程同时输出
/*      Run02 R1 = new Run02();
        R1.setName("线程1");
        Run02 R2 = new Run02();
        R2.setName("线程2");
        R1.start();
        R2.start();*/
        
    }

}

（1）通过用Runnable 实现 1~100的输出 俩个线程同时输出

package com.lty.yu;

public class Run implements Runnable{
    //1.通过用Runnable 实现 1~100的输出 俩个线程同时输出
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 0; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
        
    }
    
}

（2）用继承Thread类的方法 实现1~100的输出 俩个线程同时输出

package com.lty.yu;

public class Run02 extends Thread {
    // 2.用继承Thread类的方法 实现1~100的输出 俩个线程同时输出
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {

            System.out.println(Thread.currentThread().getName() + ":" + i);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }
}