java多线程典型例子及分析

java多线程典型例子及分析

线程的一些常用简单的知识点

• join() Thread提供了让一个线程等待另一个线程完成的方法–join()方法：比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，B才会继续执行。
• yield() 线程如果调用了yield()方法可以让运行状态的线程转入就绪状态。这个方法一般不用，原因：因为如果你将某个线程调用该方法之后，可能马上又会执行，也可以能稍后执行，结果不确定。
• sleep() 需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用Thread类的静态sleep()方法来实现。而不能使用yield()。
• setDaemon(boolean on) 将该线程标记为守护线程或用户线程。在后台运行，它的任务是为其他的线程提供服务，这种线程称为”后台线程(Daemon Thread)”。
• setPriority(int newPriority)和getPriority() Thread类提供了setPriority(int newPriority)与getPriority()方法来设置与获取线程优先级setPriority方法的参数可以是一个整数，范围是1~10,也可使用下面的3个静态常量：MAX_PRIORITY:值是10、MIN_PRIORITY:值是1、NORM_PRIORITY:值是5(这是默认值)

---

一些常见的多线程例子

1. 如何继承Thread,创建自己的多线程类
2. 如何实现Runable,创建多线程
3. Synchronized的不同作用域的使用
4. Synchronized的死锁的例子等

如何继承Thread,创建自己的多线程类:该方法不推荐使用，因为继承类有很大的局限性（自行了解）；如果继承Thread，不能实现多个线程共享一个实例对象。

public class Demo2Thread {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        myThread1.setName("线程一：");
        myThread2.setName("线程二：");
        myThread1.start();
        myThread2.start();
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                System.out.println(getName() + ":" + i);
                sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    }
}

如何实现Runable,创建多线程：创建线程类推荐使用该方法。

public class Demo2Runable {
        public static void main(String[] args) {
            /*
             * 可以共享数据
             */
            MyRunable myRunable = new MyRunable();
            Thread thread1 = new Thread(myRunable);
            Thread thread2 = new Thread(myRunable);
            thread1.setName("线程一：");
            thread2.setName("线程二：");
            thread1.start();
            thread2.start();
        }
    }

    class MyRunable implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        }
    }

Synchronized作用于全局变量：通过对需要多个线程访问的变量的加锁，保证数据正确性。

public class Demo2Synchronized2Filed {
    public static void main(String[] args) {
        Account account = new Account("1", 1024);
        /*
         * 保证数据共享，即两个线程共享一个people和一个account。不然无从谈起线程的同步与否
         */
        People people = new People(account);
        Thread thread1 = new Thread(people);
        Thread thread2 = new Thread(people);
        thread1.setName("丈夫");// 设置线程的名字
        thread2.setName("妻子");
        thread1.start();
        thread2.start();
    }
}

class People implements Runnable {
    private Account account;

    public People(Account account) {
        super();
        this.account = account;
    }

    @Override
    public void run() {

        while (true) {
            /*
             * 对account加锁，保证每次操作account是一个原子操作，实现数据的完整性
             */
            synchronized (account) {
                if (account.getMoney() <= 100) {
                    System.out.println(Thread.currentThread().getName()
                            + "余额不足");
                    break;
                }
                int remain = account.getMoney() - 100;
                account.setMoney(remain);
                System.out.println(Thread.currentThread().getName()
                        + "取了100元，剩余" + remain + "元");
            }
        }

    }

}

/*
 * 一个简单的银行卡对象类
 */
class Account {
    public Account(String id, int money) {
        super();
        this.id = id;
        this.money = money;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    private String id;
    private int money;
}

Synchronized作用于方法：作用同3，用法也很简单。

public class Demo2Synchronized2Method {
    public static void main(String[] args) {
        MyDemo2Synchronized2Method myDemo2Synchronized2Method = new MyDemo2Synchronized2Method();
        Thread thread1 = new Thread(myDemo2Synchronized2Method);
        thread1.start();
        Thread thread2 = new Thread(myDemo2Synchronized2Method);
        thread2.start();
    }
}

class MyDemo2Synchronized2Method implements Runnable {
    @Override
    public void run() {
        // TODO Auto-generated method stub
        count();
    }

    private synchronized void count() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

一个典型的死锁例子

• 分析： 线程一：首先线程一对o1加锁，然后sleep；这个时候线程二的o2加锁，然后o2也sleep。当o1休眠结束后，会去尝试线程一的synchronized(o2)，这个时候o2还在加锁状态，【要等待o2的锁的结束】,并且o1还在锁定状态<重要>；同时o2也休眠结束，会去尝试执行线程二的synchronized (o1),这个时候o1在锁定状态，【要等待o1的锁的结束】。形成死锁：相互等待

  /*
   * 一个死锁的例子
   */
  public class Demo2SynchronizedDeathLock {
      public static void main(String[] args) {
          MyLockDemo myLockDemo1 = new MyLockDemo();
          Thread thread1 = new Thread(myLockDemo1);
          Thread thread2 = new Thread(myLockDemo1);
          thread1.setName("线程一");
          thread2.setName("线程二");
          thread1.start();
          thread2.start();
      }
  }
  
  class MyLockDemo implements Runnable {
      Object o1 = new Object();
      Object o2 = new Object();
  
      /*
       * 分析： 线程一：首先线程一对o1加锁，然后sleep；这个时候线程二的o2加锁，然后o2也sleep。
       * 当o1休眠结束后，会去尝试线程一的synchronized
       * (o2)，这个时候o2还在加锁状态，【要等待o2的锁的结束】,并且o1还在锁定状态<重要>；同时o2也休眠结束，会去尝试执行线程二的
       * synchronized (o1),这个时候o1在锁定状态，【要等待o1的锁的结束】。形成死锁：相互等待
       */
      @Override
      public void run() {
          if (Thread.currentThread().getName().equals("线程一")) {
              synchronized (o1) {
                  System.out.println(Thread.currentThread().getName() + "对o1加锁啦");
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      // TODO Auto-generated catch block
                      e.printStackTrace();
                  }
                  synchronized (o2) {
                      System.out.println(Thread.currentThread().getName()
                              + "对o2加锁啦");
                  }
              }
  
          } else {
              synchronized (o2) {
                  System.out.println(Thread.currentThread().getName() + "对o2加锁啦");
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      // TODO Auto-generated catch block
                      e.printStackTrace();
                  }
                  synchronized (o1) {
                      System.out.println(Thread.currentThread().getName()
                              + "对o1加锁啦");
                  }
              }
  
          }
  
      }
  }