java：多线程

进程和线程的区别:
在操作系统中运行的程序就是进程,比如你的QQ,播放器,游戏,IDE等等…
一个进程可以有多个线程,如视频中同时听声音,看图像,看弹幕,等等

程序运行起来就变成进程了,进程中包含线程

1.说起进程,就不得不说下程序.程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念
2.而进程则是执行程序的一次执行过程,它是一个动态的概念,是系统资源分配的单位
3.通常在一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义,线程是CPU调度和执行的单位

注意:很多多线程是模拟出来的,真正的多线程是指有多个cpu,即多核,如服务器.如果是模拟出来的多线程,即在一个cpu的情况下,在同一个时间点,cpu只能执行一个代码,因为切换的很快,所以就有同时执行的错觉

本章核心概念:
1.线程就是独立的执行路径
2.在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程,gc线程
3.main()称之为主线程,为系统的入口,用于执行整个程序
4.在一个进程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统紧密相关的,先后顺序是不能人为的干预的
5.对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制
6.线程会带来额外的开销,如cpu调度时间,并发控制开销
7.每个线程在自己的工作内存交互,内存控制不当会造成数据不一致

创建线程类3种方法:1.继承Thread类 2.实现Runnable接口 3.实现callable接口
Thread(不建议使用,避免单继承局限性)
1.自定义线程类继承Thread类
2.重写run()方法,编写线程执行体
3.创建线程对象,调用start()方法启动线程

public class TestThread1 extends Thread {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("我在看代码---" + i);
        }
    }

    public static void main(String[] args) {
        //main线程,主线程
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start()方法开启线程
        //testThread1.run();   //并没有开启一个新的线程,所以先执行完run方法,再继续往下执行
        testThread1.start();//开启一个子线程,和主线程同时执行

        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线程--" + i);
        }
    }
}

实现Runnable接口:(推荐使用,避免单继承局限性,灵活方便,方便同一个对象被多个线程使用)

package thread;
//开启线程的方式和继承Thread不同
public class TestThread2 implements Runnable {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("我在看代码---" + i);
        }
    }

    public static void main(String[] args) {
        //main线程,主线程
        //创建一个线程对象
        TestThread2 testThread2 = new TestThread2();
        //调用start()方法开启线程
        //new Thread(testThread2).run();   //并没有开启一个新的线程,所以先执行完run方法,再继续往下执行
        new Thread(testThread2).start();//执行线程需要丢入Runnable接口(Thread类本身也实现了Runnable接口)

        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线程--" + i);
        }
    }
}

并发问题

//多个线程同时操作同一个对象
//买火车票的例子
public  class TestThread implements Runnable {
    //票数
private int ticketNums=10;
    @Override
    public void run() {
        while (true){
            if (ticketNums<=0){
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums+"张票");

        }
    }

 

线程状态:

线程停止:

package state;
//测试stop
//1.建议线程正常停止--->利用次数,不建议死循环
//2.建议使用标识位--->设置一个标识位
//3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
public class TestStop implements Runnable {
    //1.设置一个标识位
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run....Thread" + i++);
        }
    }

    //2.设置一个公开的方法停止线程,转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main" + i);
            if(i == 900){
                //调用stop方法切换标志位,让线程停止
                testStop.stop();//停止后就只有主线程在跑了
                System.out.println("线程该停止了");
            }
        }
    }
}

线程休眠:
sleep(时间)指定当前线程阻塞的毫秒数;
sleep存在异常InterruptedException;
sleep时间到达后线程进入就绪状态;
sleep可以模拟网络延时,倒计时等;
每一个对象都有一个锁,sleep不会释放锁; 

线程礼让:
礼让线程,让当前正在执行的线程暂停,但不阻塞
将线程从运行状态转为就绪状态
让cpu重新调度,礼让不一定成功!看CPU心情 (重新竞争CPU) 

package state;

public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield, "a").start();
        new Thread(myYield, "b").start();
    }
}

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();//礼让 加了礼让则就算一个线程开始了,也会重新竞争cpu
        System.out.println(Thread.currentThread().getName() + "线程结束执行");
    }
}

Join:
Join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞
可以想象成插队

package state;
//测试join方法,可以想象成插队
public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("join" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        for (int i = 0; i < 100; i++) {
            if(i == 50){
                thread.join();//开始主线程和子线程同时执行,但当i==50时,只让子线程执行
            }
            System.out.println("main..." + i);
        }
    }
}