JAVA线程同步实例教程

线程是java程序设计里非常重要的概念，本文就以实例形式对此加以详细解读。具体分析如下：

首先，线程加锁有什么用处呢？举个例子：比如你现在有30000块大洋在银行存着，现在你到银行取钱，当你输入密码完成后，已经输入取款金额，比如你输入的是20000，就是在银行给你拿钱这个时刻，你老婆也去银行取这笔钱，你老婆同样取20000，因为此时你的账上仍然是30000，所以银行同样的操作在你老婆那端又进行了一遍，这样当你们两个完成各自操作后，银行记录的你账上还应该有10000块存款，这样是不是很爽。解决这个问题就用到了线程加锁的知识，下面就让我们一起来学习一下吧。

一、未处理线程同步的一个例子：

public class textsync implements runnable{
  /**未处理线程同步
   * @param args
   */
  time time = new time();
  public static void main(string[] args) {
    textsync text = new textsync();
    thread t1 = new thread(text);
    thread t2 = new thread(text);
    t1.setname("t1");
    t2.setname("t2");
    t1.start();
    t2.start();
  }
  @override
  public void run() {
    time.add(thread.currentthread().getname());
  }
}
class time {
  private static int num = 0;
  public void add(string name){
    try {
      num++;
      //当第一个线程执行到此时，num变成了1，第一个线程暂停一秒，
      //第二个线程开始执行，当第二个线程执行到此时，num变成了2，第二个线程暂停一秒，
      //第一个线程此时的num同样变成了2，所以最终的结果均为2；
      thread.sleep(1000);
    } catch (interruptedexception e) {
      e.printstacktrace();
    }
    system.out.println(name+"是第"+num+"个执行的线程。");
  }
}

输出结果：

t2是第2个执行的线程。
t1是第2个执行的线程。

二、线程同步

public class textsynctwo implements runnable{
  /**线程同步
   * @param args
   */
  time1 time = new time1();
  public static void main(string[] args) {
    textsynctwo text = new textsynctwo();
    thread t1 = new thread(text);
    thread t2 = new thread(text);
    t1.setname("t1");
    t2.setname("t2");
    t1.start();
    t2.start();
  }
  @override
  public void run() {
    time.add(thread.currentthread().getname());
  }
}
class time1 {
  private static int num = 0;
  
  //synchronized锁定当前线程，可以在方法定义时进行声明，或采用在方法中进行设置。
  public synchronized void add(string name){
    //synchronized (this) {//锁定当前线程，防止此时被别的线程执行
      try {
        num++;
        thread.sleep(1000);
      } catch (interruptedexception e) {
        e.printstacktrace();
      }
      system.out.println(name+"是第"+num+"个执行的线程。");
    //}
  }
}

输出结果：

t1是第1个执行的线程。
t2是第2个执行的线程。

三、死锁

public class testdeadlock implements runnable{
  /**死锁
   * @param args
   */
  private int flag = 0 ; 
  static object o1 = new object();
  static object o2 = new object();
  public static void main(string[] args) {
    testdeadlock td1 = new testdeadlock(); 
    testdeadlock td2 = new testdeadlock(); 
    td1.flag = 1;
    td2.flag = 2;
    thread t1 = new thread(td1); 
    thread t2 = new thread(td2);
    t1.setname("t1");
    t2.setname("t2");
    t1.start();
    t2.start();
  }

  @override
  public void run() {
    system.out.println(thread.currentthread().getname());
    if(flag == 1){
      synchronized(o1){
        try {
          thread.sleep(5000);
        } catch (interruptedexception e) {
          e.printstacktrace();
        }
        synchronized(o2){
          system.out.println("1");
        }
      }
    }
    if(flag == 2){
      synchronized(o2){
        try {
          thread.sleep(5000);
        } catch (interruptedexception e) {
          e.printstacktrace();
        }
        synchronized(o1){
          system.out.println("2");
        }
      }
    }
  }
}

四、锁定

public class tt implements runnable{
  /**锁定
   * @param args
   */
  int b = 100;
  public static void main(string[] args) {
    tt tt = new tt();
    thread th = new thread(tt);
    th.start();
    try {
      tt.m2();
    } catch (exception e) {
      e.printstacktrace();
    }
    system.out.println(tt.b);
  }
  @override
  public void run() {
    try {
      m1();
    } catch (exception e) {
      e.printstacktrace();
    }
  }
  private synchronized void m1() throws exception{
    b = 1000;
    thread.sleep(5000);
    system.out.println("b="+b);
  }
  private synchronized void m2() throws exception{
    thread.sleep(2500);
    b = 2500;
  } 
}

现在的输出结果是：

1000
b=1000

可见这里m2先执行，m1要等m2执行完毕后方可执行。

希望本文所述对大家的java程序设计有所帮助