并发编程

什么是进程？

程序是静止的，运行中的程序就是进程。
进程的三个特征：

• 动态性：进程是运行中的程序，要动态的占用内存、CPU和网络等资源
• 独立性：进程与进程之间是相互独立的，彼此有自己的独立内存区域
• 并发性：CPU单核同一时刻其实内存中只有一个进程在被执行。CPU会分时轮询切换依次为每个进程服务，因速度快，给我们的感觉是这些进程在同时执行，这就是并发性。
  并行：同一时刻同时有多个在执行

什么是线程？

• 线程属于进程，一个进程可以包含多个进程，这就是多线程
• 线程是进程中的一个独立执行单元
• 线程创建开销相对于进程来说比较小
• 线程也支持并发性

线程的作用

• 提高程序的效率，线程也支持并发性，可以有更多的机会得到CPU
• 多线程可以解决很多业务模型

线程的创建方式一

继承Thread类的方式

1.定义一个线程类继承Thread类
2.重写run()方法
3.创建一个新的线程对象
4.调用线程对象的start()方法启动线程

public class ThreadDemo {
    //将启动后的ThreadDemo当成一个进程
    //main方法是由主线程执行的，理解成main方法就是一个主线程
    public static void main(String[] args){
        //3.创建一个线程对象
        Thread t = new MyThread();
        //4.调用线程对象的start()方法启动线程，最终还是执行run()方法
        t.start();
        for(int i = 0; i < 5; i++){
            System.out.println("主线程输出："+i);
        }
}
}
//1.定义一个线程类继承Thread类
class MyThread extends Thread{
    //2.重写run()方法

    @Override
    public void run() {
        //线程的执行方法
        for(int i = 0; i < 5; i++){
            System.out.println("子线程输出："+i);
        }
    }
}

继承Thread类的优缺点

优点：编码简单
缺点：线程类已经继承了Thread类无法继承其他类了，功能不能通过继承拓展

小结

• 线程类是继承了Thread的类
• 启动线程必须调用start()方法
• 多线程是并发抢占CPU执行，所以在执行过程中会出现并发随机性

注意事项

1.线程的启动必须调用start()方法，否则当成普通类处理。

• 如果线程直接调用run()方法，相当于变成了普通类的执行，此时将只有主线程在执行他们
• start()方法底层其实是给CPU注册当前线程，并且触发run()方法执行
  2.建议线程先创建子线程，主线程的任务放在之后。

Thread类的常用API

• public void setName(String name)
  

• public void getName()
  

• public static Thread currentThread()
  

public class ThreadDemo {
    //将启动后的ThreadDemo当成一个进程
    //main方法是由主线程执行的，理解成main方法就是一个主线程
    public static void main(String[] args){
        //3.创建一个线程对象
        Thread t1 = new MyThread();
        t1.setName("1号");
        t1.start();
        Thread t2 = new MyThread();
        t2.setName("2号");
        t2.start();
        //4.调用线程对象的start()方法启动线程，最终还是执行run()方法
        Thread m = Thread.currentThread();
        m.setName("主线程");
        for(int i = 0; i < 100; i++){
            System.out.println(m.getName()+"==>"+i);
        }
}
}
//1.定义一个线程类继承Thread类
class MyThread extends Thread{
    //2.重写run()方法

    @Override
    public void run() {
        //线程的执行方法
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName()+"==>"+i);
        }
    }
}

通过有参构造器取名

public class ThreadDemo {
    //将启动后的ThreadDemo当成一个进程
    //main方法是由主线程执行的，理解成main方法就是一个主线程
    public static void main(String[] args){
        //3.创建一个线程对象
        Thread t1 = new MyThread("1号");
        //t1.setName("1号");
        t1.start();
        Thread t2 = new MyThread("2号");
        //t2.setName("2号");
        t2.start();
        //4.调用线程对象的start()方法启动线程，最终还是执行run()方法
        Thread.currentThread().setName("主线程");
        //m.setName("主线程");
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName()+"==>"+i);
        }
}
}
//1.定义一个线程类继承Thread类
class MyThread extends Thread{
    public MyThread(String name) {
        //public Thread(String name):父类的有参数构造器
        super(name);//调用父类的有参数构造器初始化当前线程对象名称
    }
    //2.重写run()方法

    @Override
    public void run() {
        //线程的执行方法
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName()+"==>"+i);
        }
    }
}