java学习笔记之初识多线程

初识多线程

一.进程的认识：

　　1.进程的理解：

　　进程可以理解成正在执行的任务，就是正在运行的程序，进程又分为两种，一种是前台进程，就是我们很直观看见的，另一种是后台进程，就是操作系统启动就有的(系统级的进程)，每个进程运行之后都会占用一定的cpu和内存资源；

　　比如说：我们打开window任务管理器就可以看到有很多的进程，里面有用户开启的，也有操作系统启动的进程

　　2.进程的调度：

　　也就是那么多的进程，cpu是怎样运行的呢？

　　采用时间片轮转法

 

二.线程认识

　　1.线程的理解

　　　　线程是在进程的内部运行的执行体

　　　　(1).一个进程可以创建多个线程

　　　　(2).进程和线程共同来争夺cpu，而且概率是均等的

　　　　(3).线程依赖进程，不能独立存在

　　　　(4).在java中，一个进程至少有一个线程，main方法被称为主线程；

　　　　　　我们可以在java的main方法中输出一个1/0；

　　　　(5).进程或者线程都有优先级，优先级高的可以得到更多的时间片和cpu的执行权

　　　　(6).抢占式调度：优先级高的进程可以抢占优先级低的cpu执行权

　　2.为什么要搞多线程？

　　　原因：

　　　　(1).让多个程序同时执行

　　　　(2).提高程序的执行效率

三.线程的创建

　　1.方式一：继承Thread类

　　　　小demo：

//定义一个类，继承Thread类
public  class  MyThread  extends  Thread {

    //重写Thread类的run方法    
    public void run(){
        System.out.print("我是一个子线程");  
    }
}

　　

public class Demo {
    public static void main(String[] args) {
        //创建子类对象，然后调用start();方法
        MyThread mt=new MyThread();
        mt.start();
    }
}

　　2.方式二：实现Runnable接口

　　　　小demo：

//实现类的定义
public class MyRunnableImpl  implements Runnable {
    //定义一个Runnable实现类，然后重写run方法
    @Override
    public void run() {
        //这里写功能代码
    }
}

public class Demo {
    //使用代码
    public static void main(String[] args) {
        //new 一个Runnable实现类对象
        MyRunnableImpl my=new MyRunnableImpl();
        //然后将该实现类对象，传入Thread类的构造方法中，并创建Thread类对象
        //调用Thread对象start()方法开启线程
        new Thread(my).start();
    }
}

　　3.关于线程的一些方法使用

　　

public class Demo {
    public static void main(String[] args) {
        /*
         * 设置线程的名字：方法一
         * 1.通过Thread 类的setName(String  name)方法
         */
        MyThread mThread=new MyThread();
　　　　　　　　mThread.setName("线程名字");
        mThread.start();
        /*
         * 设置线程名字：方法二
         * 2.通过Thread的构造方法
         * Thread(Runnable r,String name);
         */
        //创建Runnable实现类的对象
        MyRunnable mr=new MyRunnable();
        new Thread(mr,"线程名称").start();
        
    }
}

public class MyThread extends Thread {
    public void run(){
        /*
         * 获取线程的名字的方法
         * 1.通过Thread类的getName()方法
         * 
         * 2.通过Thread类的静态方法currentThread()获取正在当前线程的对象
         *     然后通过getName(),获得线程名称
         */
        System.out.println("方法一线程的名字是："+getName());
        System.out.println("方法二线程的名字是："+Thread.currentThread().getName());
    }
}

四.线程的安全

 　　1.线程安全问题产生的原因：

　　　　　　当多个线程去访问共享资源时候，就会发生线程安全问题

　　　　先看一个案例：多窗口卖电影票的案例

class  Ticket implements Runnable {
    //电影票的数量
    private static  int ticket=100;
    @Override
    public void run() {
        while(true){
            if(ticket>0){
                //模拟网络延时的场景
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                //对票数进行出售(减减操作)
                System.out.println("正在售出第"+ticket--+"张票");
            }
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        //new 一个实现类对象
        Ticket  t=new Ticket();
        //创建3个线程对电影票进行售卖
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
        
    }
}

　　这时候就出现了问题：

　　　　

　　　　出现这个问题的解释：

　　　　　　当拥还剩一张电影票的时候，拥有cpu执行权的线程运行到while(true)的时候，顺利通过，然后在运行sleep();这时候这个线程进入堵塞状态，电影票还是1，cpu的执行权被另一个线程拿到，也正好运行到while(true)，顺利通过，然后在运行sleep();cpu执行权被第三个线程抢去，同样的运行，到最后醒过来的线程会继续执行下面的代码。就产生了负数票的现象

　　 2.线程安全问题的解决方案：

　　　　 (1).同步代码块

　　　　

     
     //定义一个对象，当做锁对象
     static Object obj = new Object();
     /*
        同步代码块：
        参数：锁对象
        1:java任何对象都可以作为锁对象
        2:所有的线程都必须共享这个锁对象(该对象只有一份)
        synchronized(mutex){
            //存放需要加锁的代码
        }
      */
    
    //实现卖票的代码
    @Override
    public void run() {
        
        while(true){
            synchronized (obj) {//加锁
                if(tickets > 0 ){
                    //模拟一个网络的延时
                    try{Thread.sleep(50);}catch(Exception e){}
                    System.out.println("正在出售第"+ tickets-- + "张票");
                }
            }//解锁
        }
    }

 　　　　(2).同步方法

    /*
     * 同步方法：对整个方法加锁
     * 
     * 1:同步方法的锁对象是this,  这里的this必须是同一个
     * 2:静态方法的锁对象是：类名.class
     */
    /*
     * 同步代码块和同步方法的区别:
     *     1:同步代码块可以对任何一段代码进行加锁
     *  2:同步方法是对整个方法都进行加锁
     *  
     *  
     *  3:同步代码块的对象可以自己指定
     *  4:同步方法的锁对象必须是this
     */
    public synchronized void method(){
        if (tickets > 0) {
            // 模拟一个网络的延时
            try {
                Thread.sleep(50);
            } catch (Exception e) {
            }
            System.out.println("正在出售第" + tickets-- + "张票");
        }
    }

    // 实现卖票的代码
    @Override
    public void run() {

        while (true) {
            method();
        }
    }

 　　　　(3).同步锁

/*
     * 同步锁：
     *  Lock接口:
     *      ReentrantLock实现类:
     *         lock()；    加锁
     *         unlock()；解锁
     */
    
    //1:创建锁对象
    ReentrantLock rt = new ReentrantLock();
    
    
    // 实现卖票的代码
    @Override
    public void run() {

        while (true) {
            //2:在适当的地方加锁
            rt.lock();
            
            if (tickets > 0) {
                // 模拟一个网络的延时
                try {
                    Thread.sleep(50);
                } catch (Exception e) {
                }
                System.out.println("正在出售第" + tickets-- + "张票");
            }
            //3:在适当的地方解锁
            rt.unlock();
        }
    }

五.线程的状态