线程是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程序设计有所帮助