JAVA篇_多线程及其常见方法

一、线程的概念及相关描述

• 线程是程序中执行的线程。 Java虚拟机允许应用程序同时执行多个执行线程。

• 每个线程都有优先权。 具有较高优先级的线程优先于优先级较低的线程执行。 每个线程可能也可能不会被标记为守护程序。 当在某个线程中运行的代码创建一个新的Thread对象时，新线程的优先级最初设置为等于创建线程的优先级，并且当且仅当创建线程是守护进程时才是守护线程

• 当Java虚拟机启动时，通常有一个非守护进程线程（通常调用某些指定类的名为main的方法）。 Java虚拟机将继续执行线程，直到发生以下任一情况：

  • 已经调用了Runtime类的exit方法，并且安全管理器已经允许进行退出操作。
  • 所有不是守护进程线程的线程都已经死亡，无论是从调用返回到run方法还是抛出超出run方法的run 。

• 每个线程都有一个用于识别目的的名称。 多个线程可能具有相同的名称。 如果在创建线程时未指定名称，则会为其生成一个新名称。除非另有说明，否则将null参数传递给null中的构造函数或方法将导致抛出NullPointerException 。

二、线程的几个状态

 
线程状态:新生、就绪、运行、死亡、阻塞

三、线程的相关方法及说明

1.1 start()

        启动线程。

1.2 stop()

        停止线程，过期不建议使用。

1.3 Thread.sleep( long ms )

        睡眠 暂停执行，直到睡眠时间到。但是不会释放资源即锁。

        如果线程是通过继承Thread实现的话这2个方法没有区别；
        如果线程是通过实现Runnable接口来实现的,则不是Thread类,不能直接使用Thread.sleep()
        必须使用Thread.currentThread()来得到当前线程的引用才可以调用sleep(),
        所以要用Thread.currentThread().sleep()来睡眠。在多线程情况下区别特别明显。

1.4 setName()/getName()

        取名字/获得名字，如果没有设置名字，默认名字为Thread-(0-n)

Thread zsxc=new Thread(ls,"张三");
        zsxc.setName("张三");

1.5 Thread.yield()

        线程礼让. 让出cpu执行时间片，自己进入就绪状态，再次等待调度，不阻塞。

public class threadYield {
    public static void main(String[] args) {
        testThread ls=new testThread();
        Thread zsxc=new Thread(ls,"张三");
        zsxc.setName("张三");
        Thread lsxc=new Thread(ls,"李四");
        lsxc.start();
        zsxc.start();
    }
}
class  testThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"start");
        if (Thread.currentThread().getName().equals("张三")){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"stop");
    }
}

1.6 join()（少用）

        同步,加入线程线程中，等待此线程执行完毕，其他线程才能进行，所以在此线程执行过程中，其他线程处于阻塞状态，如果出现此线程执行时间较长等情况，程序可能崩溃。

public class threadJion implements Runnable{
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(new threadJion());
        thread.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程  "+i);
            if (i==20){
                thread.join();
            }
        }
    }
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("run   "+i);
        }
    }
}

1.7 setDeamon(boolean xx)/isDeamon()

        设置守护线程/判断守护线程

1.8 setPriority(int xx)/getPriority()     

        优先级越高只能说明它更容易抢到cpu的时间片，但这不是绝对的，就类似于我一个人抢票和十个人抢票，当然是个人的那一方更容易中，但这也不是绝对的。线程优先级为1~10；

        设置/获取优先级 ,默认三个 MIN_PRIORITY = 1;NORM_PRIORITY = 5;MAX_PRIORITY = 10; 默认为5

public class threadPriority {
    public static void main(String[] args) {
        testPriority t=new testPriority();
        Thread a=new Thread(t,"线程a： ");
        Thread b=new Thread(t,"线程b： ");
        Thread c=new Thread(t,"线程c： ");
        Thread d=new Thread(t,"线程d： ");
        System.out.println("主："+Thread.currentThread().getPriority());
        a.setPriority(1);
        b.setPriority(5);
        c.setPriority(10);
        System.out.println(a.getPriority());
        System.out.println(b.getPriority());
        System.out.println(c.getPriority());
        System.out.println(d.getPriority());
        a.start();
        b.start();
        c.start();
    }
}
class testPriority implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName()+"  "+i);
        }
    }
}

1.9 isAlive()

        测试线程是否处于活动状态

1.10 toString

        输出线程信息，包括名字，优先级，线程组等。

1.11 getState() 返回值Thread.State类型

       new(新生)尚未启动的线程转台

        runnable(运行)在java虚拟机中运行线程就是此状态 可运行(运行)在java虚拟机中运行线程就  是此状态)

        blocked(阻塞状态）被阻塞等待监视器锁定的线程就处于此状态

        waiting(等待状态）正在等待另—线程执行特定动作的线程处于此状态 阻塞(阻塞状态)被阻塞等待监视器锁定的线程就处于此状态等待(等待状态)正在等待另-线程执行特定动作的线程处于此状态))

        time_waiting(等待到达时间状态）正在等待另一线程执行动作到达指定等待时间的线程处于此状态

        terminated(退出）已退出的线程处于此状态 时间等待(等待到达时间状态)正在等待另一线程执行动作到达指定等待时间的线程处于此状态终止(退出)已退出的线程处于此状态)

测试代码：

  ​​​​​​

public class threadState {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try { Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace(); }
            } });
        t.start();
        //当线程没有死亡时循环输出其状态
        while (t.getState()!= Thread.State.TERMINATED){
            System.out.println(t.getState());
            Thread.sleep(5);
        }
    }
}

测试结果：

1.12setDaemon(boolean）

        将此线程标记为 daemon线程或用户线程。

        比如main线程，其中gc()线程就是他的守护线程，main死亡gc() ,就跟着死亡（可能不会立即死亡，要等他的时间片到期之后死亡，或者JVM处理完成）

public class threadDeamon {
    public static void main(String[] args) {
        people p=new people();
        god g=new god();
        Thread b=new Thread(g,"上帝：");
        b.setDaemon(true); //设置上帝线程为守护线程 true
        b.start();
        Thread a=new Thread(p,"人：");
        a.start();
    }
}
class people implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("我"+i+"岁了");
        }
        System.out.println("我死了");
    }
}
class god implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("上帝守护人");
        }
    }
}

四、线程同步异步问题

1. 线程异步      

  异步：一个线程不需要等待另一个线程执行完毕后才执行，从宏观上看线程是同时执行，但是微观上是一个线程执行一点点后，另外一个线程又执行一点点，这样交替执行。线程默认是异步的，同步需要自己控制

       并发：多个线程同时访问一个对象（异步）

       多个线程对同一个对象进行访问和修改的时候，数据时不安全的，可能会出现数据紊乱或者不符合常理的数据。

        并发引起问题的案例（抢票）：

public class threadTongbu implements Runnable {
    public static void main(String[] args) {
        threadTongbu t=new threadTongbu();
        Thread hn=new Thread(t,"黄牛");
        Thread fs=new Thread(t,"粉丝");
        Thread pf=new Thread(t,"票贩子");
        hn.start();
        fs.start();
        pf.start();
    }

    int ticket=10;
    boolean flag=true;
    @Override
    public void run() {
        while (flag){
                try {
                    by();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    }
    public void by() throws InterruptedException {
        if (ticket<1){
            flag=false;
            return;
        }
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"抢到了第"+(ticket--)+"张");
    }
}

运行结果：

不难看出，运行结果中，第七张票被抢了2次，甚至有第0张票的出现，这就是并发（异步执行）引起的数据紊乱和数据的不安全。

2. 线程同步

          同步：一个线程全部做完以后，另一个线程才开始执行，也就是一个线程的开始总是接着另一个线程的结尾。

        线程同步确保了数据的安全性。

    1.同步方法实现同步：使用 synchronized  xxx( ){ } 同步方法的方式，它原理当线程执行到有synchronized的方法是，先尝试去获取this对象(也就是自身)的锁(每个对象有且只有一把)，如果取到了则进入方法执行，期间不被打扰（如果这时有其他线程准备进入该方法但是取不到锁），直到上一个对象释放锁. 

就上面的案例改写（）：

public class threadTongbu implements Runnable {
    public static void main(String[] args) {
        threadTongbu t=new threadTongbu();
        Thread hn=new Thread(t,"黄牛");
        Thread fs=new Thread(t,"粉丝");
        Thread pf=new Thread(t,"票贩子");
        hn.start();
        fs.start();
        pf.start();
    }

    int ticket=10;
    boolean flag=true;
    @Override
    public void run() {
        while (flag){
                try {
                    by();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    }
    public synchronized void by() throws InterruptedException {
        if (ticket<1){
            flag=false;
            return;
        }
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"抢到了第"+(ticket--)+"张");
    }
}

 运行效果图:

可见,在修改后,我使用了synchronized()对方法加锁,它锁的是自身的对象,也就是this,这里就是t这个对象, 意味着在自身代码没有执行完之前,其他线程拿不到该对象的锁,那么也将无法执行其中的代码, 只能阻塞,在此代码执行完之后,其他的线程才能拿t对象的锁.保证了数据不会出现紊乱.

  2.同步代码块实现同步：使用 synchronized( obj ){ 被同步代码 } 同步代码块方式，它原理当线程执行到有synchronized的代码块时，先尝试去获取obj 对象的锁(每个对象有且只有一把)，如果取到了则进入代码块中执行，期间不被打扰（如果这时有其他线程准备进入代码块但是取不到锁），直到执行完毕后，自动归还锁。其他线程方可进入。（基本数据类型无法加锁，只能使用他的引用数据类型加锁）

测试案例(银行取钱)

        

public class BankWindow implements Runnable {
    card card;
    double money;
    @Override
    public void run() {
            if (card.getSalary()-money>0){
                System.out.println(Thread.currentThread().getName()+"当前余额"+card.getSalary());
                card.salary-=money;
                System.out.println(Thread.currentThread().getName()+"取了："+money);
                System.out.println(Thread.currentThread().getName()+"还剩："+card.getSalary());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {
                System.out.println(Thread.currentThread().getName()+":余额不足");
            }
    }
    public BankWindow(classExmaple.Synchron.card card, double money) {
        this.card = card;
        this.money = money;
    }
}

运行结果:

 我们发现.,这里出现了错误,两个人同时读到了余额,同时取钱,余额出现了负数,当然这在真实的环境下时不允许发生的,所以我们要对其加锁,由于在整个过程中,涉及到增删改查的时银行卡,所以我们对card加锁就行了.

修正:

 public void run() {
        synchronized (card){
            if (card.getSalary()-money>0){
                System.out.println(Thread.currentThread().getName()+"当前余额"+card.getSalary());
                card.salary-=money;
                System.out.println(Thread.currentThread().getName()+"取了："+money);
                System.out.println(Thread.currentThread().getName()+"还剩："+card.getSalary());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {
                System.out.println(Thread.currentThread().getName()+":余额不足");
            }
        }
    }

效果:

 注: 我们在使用同步代码和同步方法时安全性得到了大大的提升, 但程序的效率会变低,我们尽量只对关键代码使用同步代码块或者方法,从安全和性能之间找到一个相对适合的尺度.