Thread线程同步问题详解

线程的实现

实现一个线程有两种方法

1.继承 Thread类，重写run方法

2.实现runnable接口，重写run方法

java.lang.Thread也实现了runnable接口

线程的状态

1.创建状态，实例化类后

2.可运行状态，调用run方法后

3.不可运行状态，阻塞或调用了其他的方法

4.消亡状态，run方法运行完后会destroy

线程的优先级和设置

线程的优先级是多线程环境中便于系统对线程的调度，优先级高的线程会优先执行，遵循以下原则

1.子类继承父类，继承父类的优先级

2.线程创建时，通过setPriority设置线程的优先级

3.线程的优先级是1-10之间的正整数

线程的终止和执行

不能用stop方法终止线程的运行，设定变量在run方法中循环检查，满足则执行，否则break

线程的优先级不是线程运行顺序的唯一标准

多线程的同步问题

1.为什么要引入同步机制

在多线程环境中，也许会有多个线程同时访问有限的资源

解决办法：在线程使用一个资源时为其加锁即可，加锁后其它线程不能访问

package thread;

public class Bank {

	public static void main(String[] args) {
		bank1 bank=new bank1();
		Thread t1=new moneythread(bank);
		Thread t2=new moneythread(bank);
		
		t1.start();
		t2.start();
	}
}
class bank1{
	private int money=1000;
	public int getmoney(int number) throws Exception{
		if(number<0){
			return -1;
		}else if(number>money){
			return -2;
		}else if(money<0){
			return -3;
		}
		else{
			Thread.sleep(1000);
			money-=number;
			Thread.sleep(1000);
			System.out.println("final money:"+money);
			return number;
		}
	}
	
}
class moneythread extends Thread{
	private bank1 bank;
	public moneythread(bank1 bank){
		this.bank=bank;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			System.out.println(bank.getmoney(800));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

2.java中每个对象都有锁，当访问对象的synchronize方法时，表示将该对象上锁，其它线程无法访问，直到之前方法执行完成释放锁

3.线程间的相互作用

wait and notify

wait pool

lock pool

package thread;

public class ThreadTest5 {

	public static void main(String[] args) {
		example2 e=new example2();
		thethread3 t1=new thethread3(e);
		thethread4 t2=new thethread4(e);
		
		t1.start();
		t2.start();
	}
}

class example2{
	
	private Object object;
	
	public   void excute() {
		synchronized (object) {
			for (int i = 0; i < 10; i++) {
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("hello"+i);
			}
		}
	}
	public   void excute2(){
		synchronized (object) {
			for (int i = 0; i < 10; i++) {
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("wwwwwwwwwwwww"+i);
			}
		}
	}
}
 
class thethread3 extends Thread{
	
	private example2 example;
	public thethread3(example2 example){
		this.example=example;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			this.example.excute();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
class thethread4 extends Thread{
	
	private example2 example;
	public thethread4(example2 example){
		this.example=example;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			this.example.excute2();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}