Java同步synchronized与死锁

多个线程要操作同一资源时就有可能出现资源的同步问题。

同步就是指多个操作在同一个时间段内只能有一个线程进行，其他线程要等待此线程完成之后才可以继续执行。

解决资源共享的同步操作，可以使用同步代码块和同步方法两种方式完成。

<1>同步代码块

所谓代码块就是指使用“{}"括起来的一段代码，根据其位置和声明的不同，可以分为普通代码块、构造块、静态块3种，如果在代码块上加上synchronized关键字，则此代码块就称为同步代码块。

package java_thread;
//=================================================
// File Name       :	Runnable_demo2
//------------------------------------------------------------------------------
// Author          :	Common


// 类名：MyThread_2
// 属性：
// 方法：
class MyThread_2 implements Runnable{
	private int ticket = 5;	
	
	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<10;i++){
			synchronized (this) {					//设置需要同步的操作
				if(ticket>0){
					try{
						Thread.sleep(300);
					}catch(InterruptedException e){
						e.printStackTrace();
					}
					System.out.println("卖票：ticket="+ticket--);
				}
			}
//			this.sale();												//调用同步方法
		}
	}
	
}



//主类
//Function        : 	Thread_demo2
public class Runnable_demo2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyThread_2 mt = new MyThread_2();	//实例化Runnable子类对象
		Thread t1 = new Thread(mt);							//实例化Thread类对象
		Thread t2 = new Thread(mt);							//实例化Thread类对象
		Thread t3 = new Thread(mt);							//实例化Thread类对象
		t1.start();																	//启动线程
		t2.start();																	//启动线程
		t3.start();																	//启动线程
	}

}

 

package java_thread;

class Output{
	public void output(String name){
		int len = name.length();
		synchronized(this){		//不能使用name，因为“输出1”和"输出2"两个字符串不是同一个对象
			for(int i=0;i<len;i++){
				System.out.print(name.charAt(i));
			}
			System.out.println();
		}
	}
}


public class Huchi {

	private void init(){
		final Output outputer = new Output();
		//线程1
		new Thread(new Runnable(){
			@Override
			public void run() {								//覆写Thread类中的run()方法
				while(true){
						try {
							Thread.sleep(10);
						} catch (InterruptedException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}
						//new Output().output("输出1");		//也不能new对象，new对象的话，this就不代表同一个对象了
						outputer.output("输出1");
				}
			}
		}).start();
		
		//线程2
		new Thread(new Runnable(){
			@Override
			public void run() {								//覆写Thread类中的run()方法
				while(true){
						try {
							Thread.sleep(10);
						} catch (InterruptedException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}
						//new Output().output("输出1");		//也不能new对象，new对象的话，this就不代表同一个对象了
						outputer.output("输出2");
				}
			}
		}).start();
		
	}
	
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		new Huchi().init();
	}

}

 

<2>同步方法

也可以使用synchronized关键字将一个方法声明成同步方法

//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 接口名：MyThread
// 属性：
// 方法：
class MyThread_2 implements Runnable{
	private int ticket = 5;	
	
	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<10;i++){
			this.sale();												//调用同步方法
		}
	}
	
	public synchronized void sale(){			//声明同步方法
		if(ticket>0){
			try{
				Thread.sleep(300);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			System.out.println("卖票：ticket="+ticket--);
		}
	}
	
}



//主类
//Function        : 	Thread_demo2
public class Runnable_demo2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyThread_2 mt = new MyThread_2();	//实例化Runnable子类对象
		Thread t1 = new Thread(mt);							//实例化Thread类对象
		Thread t2 = new Thread(mt);							//实例化Thread类对象
		Thread t3 = new Thread(mt);							//实例化Thread类对象
		t1.start();																	//启动线程
		t2.start();																	//启动线程
		t3.start();																	//启动线程
	}

}

死锁就是指两个线程都在等待彼此先完成，造成了程序的停滞,一般程序的死锁都是在程序运行时出现的。

多个线程共享同一资源时需要进行同步，以保证资源操作的完整性，但是过多的同步就有可能产生死锁。

生产者不断生产，消费者不断取走生产者生产的产品

//=================================================
// File Name       :	ThreadInfo_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 类名：Info
// 属性：
// 方法：
class Info{
	private String name = "张三";
	private String content = "学生";
	private boolean flag = false;
	
	public synchronized void set(String name,String content){	//设置信息名称及内容
		if(!flag){																	//标志位为false，不可以生产，在这里等待取走
			try{
				super.wait();												//等待消费者取走
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}	
		this.setName(name);								//设置信息名称							
		try{
			Thread.sleep(300);									//加入延迟
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		this.setContent(content);						//设置信息内容
		flag = false;													//标志位为true，表示可以取走
		super.notify();											//唤醒等待线程
	}
	
	public synchronized void get(){			//取得信息内容
		if(flag){															//标志位为true，不可以取走
			try{
				super.wait();										//等待生产者生产
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}		
		try {
			Thread.sleep(300);									//加入延迟
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(this.getName()+"-->"+this.getContent());	//输出信息
		flag = true;													//修改标志位为true，表示可以生产
		super.notify();											//唤醒等待线程
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}
	
}

//类名：Producer
//属性：
//方法：
class Producer implements Runnable{		//定义生产者线程

	private Info info = null;								//保存Info引用
	
	public Producer(Info info) {						//构造函数
		super();
		this.info = info;
	}

	@Override
	public void run() {
		// TODO 自动生成的方法存根
		boolean flag = false;
		for(int i=0;i<50;i++){				//50次反复修改name和content的值
			if(flag){
				this.info.set("张三", "学生");
				flag = false;
			}else{
				this.info.set("李四", "老师");
				flag = true;
			}
		}
	}
	
}

//类名：Consumer
//属性：
//方法：
class Consumer implements Runnable{		//定义生产者线程

	private Info info = null;								//保存Info引用
	
	public Consumer(Info info) {						//构造函数
		super();
		this.info = info;
	}

	@Override
	public void run() {
		// TODO 自动生成的方法存根
		for(int i=0;i<50;i++){				//50次反复修改name和content的值
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			this.info.get();
		}
	}
	
}

//主类
//Function        : 	ThreadInfo_demo
public class ThreadInfo_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Info i = new Info();
		Producer pro = new Producer(i);
		Consumer con = new Consumer(i);
		new Thread(pro).start();
		new Thread(con).start();
	}

}

停止线程运行

在多线程的开发中可以通过设置标志位的方式停止一个线程的运行

//=================================================
// File Name       :	ThreadInfo_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 类名：MYThread
// 属性：
// 方法：
class MYThread implements Runnable{
	
	private boolean flag = true;			//定义标志位属性
	
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		int i = 0;
		while(this.flag){								//循环输出
			while(true){
				System.out.println(Thread.currentThread().getName()+(i++));	//输出当前线程名称
			}
		}
	}
	
	public void stop(){							//编写停止方法
		this.flag = false;							//修改标志位
	}
	
}

//主类
//Function        : 	ThreadStop_demo
public class ThreadStop_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MYThread my = new MYThread();
		Thread t = new Thread(my,"线程");
		t.start();
		my.stop();
	}

}

互斥性

output1和output2两段代码互斥，检查的都是outputer这个对象

package java_thread;

class Output{
	public void output(String name){
		int len = name.length();
		synchronized(this){		//不能使用name，因为“输出1”和"输出2"两个字符串不是同一个对象
			for(int i=0;i<len;i++){
				System.out.print(name.charAt(i));
			}
			System.out.println();
		}
	}
	
	public synchronized void output2(String name){	//output1和output2两段代码互斥，检查的都是outputer这个对象
		int len = name.length();
		for(int i=0;i<len;i++){
			System.out.print(name.charAt(i));
		}
		System.out.println();
	}
}


public class Huchi {

	private void init(){
		final Output outputer = new Output();
		//线程1
		new Thread(new Runnable(){
			@Override
			public void run() {								//覆写Thread类中的run()方法
				while(true){
						try {
							Thread.sleep(10);
						} catch (InterruptedException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}
						//new Output().output("输出1");		//也不能new对象，new对象的话，this就不代表同一个对象了
						outputer.output("输出1");
				}
			}
		}).start();
		
		//线程2
		new Thread(new Runnable(){
			@Override
			public void run() {								//覆写Thread类中的run()方法
				while(true){
						try {
							Thread.sleep(10);
						} catch (InterruptedException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}
						//new Output().output("输出1");		//也不能new对象，new对象的话，this就不代表同一个对象了
						outputer.output2("输出2");
				}
			}
		}).start();
		
	}
	
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		new Huchi().init();
	}

}

 

static静态方法调用的对象是字节码对象，所以要把output1的this改成Output.class

package java_thread;

class Output{
	public void output1(String name){
		int len = name.length();
		synchronized(this){		//不能使用name，因为“输出1”和"输出2"两个字符串不是同一个对象
			for(int i=0;i<len;i++){
				System.out.print(name.charAt(i));
			}
			System.out.println();
		}
	}
	
	//static静态方法调用的对象是字节码对象，所以要把output1的this改成Output.class
	public static synchronized void output3(String name){	//output1和output3不同步，除非把output1的this改成Output.class
		int len = name.length();
		for(int i=0;i<len;i++){
			System.out.print(name.charAt(i));
		}
		System.out.println();
	}
	
}


public class Huchi {

	private void init(){
		final Output outputer = new Output();
		//线程1
		new Thread(new Runnable(){
			@Override
			public void run() {								//覆写Thread类中的run()方法
				while(true){
						try {
							Thread.sleep(10);
						} catch (InterruptedException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}
						//new Output().output("输出1");		//也不能new对象，new对象的话，this就不代表同一个对象了
						outputer.output1("输出1");
				}
			}
		}).start();
		
		//线程2
		new Thread(new Runnable(){
			@Override
			public void run() {								//覆写Thread类中的run()方法
				while(true){
						try {
							Thread.sleep(10);
						} catch (InterruptedException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}
						//new Output().output("输出1");		//也不能new对象，new对象的话，this就不代表同一个对象了
						outputer.output3("输出2");
				}
			}
		}).start();
		
	}
	
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		new Huchi().init();
	}

}

 this　　　　　　Output.class

　　　　

面试题：子线程循环 10 次,接着主线程循环 100,接着又回到子线程循环 10 次,接着再回到主线程又循环 100,如此循环50 次,请写出程序

package java_thread;

import java.util.concurrent.atomic.AtomicInteger;
//张孝祥java面试题28
//子线程循环 10 次,接着主线程循环 100,接着又回到子线程循环 10 次,接着再回到主线程又循环 100,如此循环50 次,请写出程序

public class TraditionalThreadCommunication {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		final Business business = new Business();
		new Thread(
				new Runnable() {
					@Override
					public void run() {
						for(int i=1;i<=50;i++){
							business.sub(i);
						}
					}
				}
		).start();
		
		for(int i=1;i<=50;i++){
			business.main(i);
		}
		
	}
}

class Business {
	private boolean bShouldSub = true;
	public synchronized void sub(int i){
		while(!bShouldSub){
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		for(int j=1;j<=10;j++){
			System.out.println("sub thread sequence of " + j + ",loop of " + i);
		}
		bShouldSub = false;
		this.notify();
	}
	  
	public synchronized void main(int i){
		while(bShouldSub){
			try {
				this.wait();
			} catch (InterruptedException e) {
					// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		for(int j=1;j<=100;j++){
			System.out.println("main thread sequence of " + j + ",loop of " + i);
		}
		bShouldSub = true;
		this.notify();
	}
}