java基础25 线程的常用方法、线程安全问题、死锁现象

一、线程的常用方法

1、Thread(String name)：初始化线程的名字
2、 setName(String name)：设置线程的名字
3、 getName()：返回线程的名字
4、 sleep(long millis)：线程睡眠指定毫秒数.静态的方法.
5、 currentThread()： 返回当前线程对象
6、 getPriority()：返回当前线程对象的优先级  默认优先级5
7、 setPriority(int newPriority)：设置线程优先级   虽然设置了优先级,但是具体的实现取决于底层操作系统实现(最大优先级数是10，最小的是1，默认的是5)

8、其他几个方法，1.8、线程生命周期处 ..............

1.1、例1   Thread()、currentThread()

 package com.zn.thread;

 /**
  * @author DSHORE / 2018-5-7
  *
  */
 public class Demo2 extends Thread {

     public Demo2(String name) {
         super(name);
     }
     @Override
     public void run() {
         //Thread.currentThread():返回当前线程对象
         System.out.println("当前线程："+Thread.currentThread());//运行结果：当前线程：Thread[二狗子线程,5,main]；说明：当前线程是二狗子线程，优先级是5
         System.out.println("this:"+this);//运行结果：this:Thread[二狗子线程,5,main]

         for(int i=;i<;i++){
             System.out.println(Thread.currentThread().getName()+i);
         }
     }
     public static void main(String[] args) {
         Demo2 d = new Demo2("二狗子线程");
         d.start();

         System.out.println("当前线程："+Thread.currentThread());//运行结果：当前线程：Thread[main,5,main] 说明：当前线程是主线程（main线程），优先级也是5

         for(int j=;j<;j++){
             System.out.println("主线程："+j);
         }
     }
 }

结果图

                   

1.2、例2    setName()、getName()

1、setName()：设置线程的名字
    2、getName()：获取线程的名字

 package com.zn.thread;

 /**
  * @author DSHORE / 2018-5-7
  *
  */
 public class Demo2 extends Thread {

     public Demo2(String name) {
         super(name);
     }
     @Override
     public void run() {//run()方法中的代码，都是自定义线程
         for(int i=;i<;i++){
             System.out.println(Thread.currentThread().getName()+i);//获取当前线程的名字
         }
     }
     public static void main(String[] args) {
         //创建一个线程对象
         Demo2 d = new Demo2("二狗子线程");
         d.setName("狗剩线程");//设置线程的名字
         d.start();

         Thread.currentThread().setName("隔壁老王线程");
         for(int j=;j<;j++){
             System.out.println(Thread.currentThread().getName()+j);
         }
     }
 }

结果图      （狗剩线程 覆盖掉了 二狗子线程）

1.3、例3     sleep()

sleep()：指定线程睡眠的时间（毫秒为单位）

 package com.zn.thread;

 /**
  * @author DSHORE / 2018-5-7
  *
  */
 public class Demo2 extends Thread {

     public Demo2(String name) {
         super(name);
     }
     @Override
     public void run() {
         for(int i=;i<;i++){
             System.out.println(Thread.currentThread().getName()+i);
             try {
                 Thread.sleep();//休眠(暂停)100毫秒       1秒 = 1000毫秒
             } catch (InterruptedException e) {//Thread类的run方法没有抛出异常类型,所以子类不能抛出异常
                 e.printStackTrace();//打印异常信息
             }
         }
     }
     public static void main(String[] args) {
         //创建一个线程对象
         Demo2 d = new Demo2("二狗子线程");
         d.start();

         Thread.currentThread().setName("隔壁老王线程");
         for(int j=;j<;j++){
             System.out.println(Thread.currentThread().getName()+j);
         }
     }
 }

运行结果图  （其中一次的运行结果）

使用sleep()方法，睡了一下，几乎都被“隔壁老王全抢了线程”；二狗子线程在后面才执行

1.4、例4      getPriority()

getPriority()：获取当前线程对象的优先级    默认优先级：5
setPriority()：设置优先级数

 package com.zn.thread;

 /**
  * @author DSHORE / 2018-5-7
  *
  */

 public class Demo3 extends Thread {
      @Override
      public void run() {
          Thread t = new Thread();//先创建线程对象，再去获取优先级数或设置优先级数
          t.setPriority();//直接设置优先级
          for(int i=;i<;i++){
              System.out.println("当前线程："+i+"\t"+t.getPriority());//getPriority()：获取该线程对象的优先级数；   默认优先级是5
          }
      }
      public static void main(String[] args) {
          //创建一个线程对象
          Demo3 d = new Demo3();
          d.start();

          Thread.currentThread().setName("隔壁老王线程");
          for(int j=;j<;j++){
              System.out.println(Thread.currentThread().getName()+j);
          }
      }
 }

结果图

                    

二、线程安全问题

2.1、java线程同步机制

方式一：同步代码块
         synchronized(锁对象){
               需要被同步的代码...
         }

方式二：同步函数

        修饰符 synchronized 返回值类型 函数名（参数类型  参数名）{

}

public synchronized void add(int a) { //即：在普通函数上面加个 synchronized 

}

2.2、同步代码块要注意的问题

1.任意的一个对象都可以作为锁对象
    2.在同步代码块中调用了sleep并不是释放锁对象.
    3.只有真正存在线程安全问题是,才使用同步代码块,否则会降低效率
    4.多线程操作的锁对象必须是唯一共享的,否则就无效了

实例1 （出现线程安全问题）

package com.zn.thread;

/**
 * @author DSHORE / 2018-5-8
 *
 * 模拟3个窗口同时在售20张票
 */

class Windows extends Thread{
    static int num=;//票数  问题1 //得使用static共享num给三个线程(w1、w2、w3)一起使用     注：这是第二张结果图的程序，第一张int num 前面是没有static的。
    public Windows(String name){
        super(name);
    }
    @Override
    public void run() {
        while(true){//问题2  此处应该加个同步锁
            if(num>){
                System.out.println(Thread.currentThread().getName()+"售出第"+num+"票");
                num--;
            }else{
            　　System.out.println("票已售罄");
            　　break;
            }
        }
    }
}
public class Demo3 {
    public static void main(String[] args) {
        //创建3个线程对象,模拟3个窗口
        Windows w1=new Windows("窗口1");
        Windows w2=new Windows("窗口2");
        Windows w3=new Windows("窗口3");
        //开启线程售票
        w1.start();
        w2.start();
        w3.start();
    }
}

运行结果图

                                    

两张图都出现了“三个窗口都有售出同一张票的情况”；即：出现了线程安全问题，解决该问题看例2

问题1：为什么出现了：售出60张票？
    答：把num这个数据共享给三个线程对象使用，使用static
问题：出现线程安全问题
    线程安全问题的解决方案：sun提供了同步机制让我们解决这类问题

实例2 （完美实例）

 package com.zn.thread;

 /**
  * @author DSHORE / 2018-5-8
  *
  * 模拟3个窗口同时在售20张票
  */
 //同步代码块    例子
 class Windows extends Thread{
     static int num = ;//票数    
     //static Object o=new Object(); //多线程操作的锁对象必须是唯一共享
     public Windows(String name){
         super(name);
     }
     @Override
     public void run() {
         while(true){
             //同步代码块
             synchronized ("锁") { //synchronized (o){  }  //任意的一个对象都可以作为锁对象
                 if(num>){
                     System.out.println(Thread.currentThread().getName()+"售出第"+num+"票");
                     try {
                         Thread.sleep();//睡眠100毫秒
                     } catch (InterruptedException e) {
                         e.printStackTrace();//打印异常信息
                     }
                     num--;
                 }else{
                     System.out.println("票已售罄");
                     break;
                 }
             }
         }
     }
 }
 public class Demo3 {
     public static void main(String[] args) {
         //创建3个线程对象,模拟3个窗口
         Windows w1=new Windows("窗口1");
         Windows w2=new Windows("窗口2");
         Windows w3=new Windows("窗口3");
         //开启线程售票
         w1.start();
         w2.start();
         w3.start();
     }
 }

运行结果图

2.3、出现安全问题的根本原因

1.存在两个或者两个以上的线程对象,而且线程之间共享一个资源.
    2.有多个语句操作了共享资源

2.4、同步函数要注意的问题

1.如果是一个非静态的同步函数，锁对象是this对象(相当于全局变量)。如果是静态的同步函数的锁，对象是当前函数锁属的类的字节码文件(class对象)。
    2.同步函数锁对象是固定的，不能由你来指定

推荐使用同步代码块
    原因：
       1.同步代码块锁对象由我们随意指定，方便控制；同步函数锁对象是固定的，不能由我们指定
       2.同步代码块可以很方便的控制需要同步的范围，同步函数必须是整个函数的所有代码都被同步了.

//需求：两人同时取钱（卡+本子）

 //同步函数  例子
class BankThread extends Thread{
    static int count=;
    public BankThread(String name) {
        super(name);
    }
    @Override
    public  void run() {
            getMoney();
    }
　　//同步函数
    public static synchronized void getMoney(){  //静态的函数---->函数所属的类的字节码文件对象 BanckThread.class唯一的
        while(true){
            if(count>){
                System.out.println(Thread.currentThread().getName()+"取走了10000,还剩"+(count-)+"元");
                count=count-;
            }else{
                System.out.println("取完了..滚蛋");
                break;
            }
        }
    }
}

public class Demo1 {
    public static void main(String[] args) {
        BankThread b=new BankThread("狗蛋");
        BankThread b1=new BankThread("铁蛋");
        b.start();
        b1.start();
    }
}
//问题：结果只有一个人能取到钱，另一个人始终没办法取到钱。原因：同步函数把所有代码都锁住了；这里应该用同步代码块

三、死锁现象

java同步机制解决了线程安全问题，但是也同时引发了死锁现象

3.1、死锁现象出现的根本原因

1.存在两个或者两个以上的线程.
    2.存在两个或者两个以上共享资源.

3.2、死锁问题的解决方案

没有方案，只能尽量避免发生而已.

3.3、实例

 package com.zn.thread;

 /**
  * @author DSHORE / 2018-5-11
  *
  * java同步机制解决了线程安全问题,但是也同时引发了了死锁现象
  *
  * 需求：两个人抢着去打开电视机，但遥控器和电池是分开的，只有一个人同时拿到遥控器和电池才能打开电视机
  */
 class DeadLock extends Thread{
     public DeadLock(String name) {
         super(name);
     }
     @Override
     public void run() {
         if("张三".equals(Thread.currentThread().getName())){
             synchronized ("电池") {
                 System.out.println("张三拿到了电池，准备去拿遥控器");
                 synchronized ("遥控器") {
                     System.out.println("张三拿到了电池和遥控器，正在打开电视机 看电视");
                 }
             }
         }else if("李四".equals(Thread.currentThread().getName())){
             synchronized ("遥控器") {
                 System.out.println("李四拿到了遥控器，准备去拿电池");
                 synchronized ("电池") {
                     System.out.println("李四拿到了遥控器和电池，正在打开电视机中");
                 }
             }
         }
     }
 }
 public class Demo4 {
     public static void main(String[] args) {
         //创建线程对象
         DeadLock d = new DeadLock("张三");
         DeadLock d1 = new DeadLock("李四");
         //开启线程
         d.start();
         d1.start();
     }
 }

运行结果图

　　　　

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：http://www.cnblogs.com/dshore123/p/9004156.html

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的 推荐，或评论，谢谢！）