java学习笔记之应用技术（一）

多线程：

创建线程方法一：

继承Thread类

1、子类覆盖父类中的run方法，将线程运行的代码存放在run中。

2、建立子类对象的同时线程也被创建。

3、通过调用start方法开启线程。

public static void main(String[] args) {
	Test t1 = new Test("haoren");
	t1.start();
	Test t2 = new Test("huairen");
	t2.start();
	}

class Test extends Thread{
	private String name;
	
	public  Test(String name){
		this.name = name;
	}
	
	public void run(){
		for(int i=0;i<10;i++){
			System.out.println(name+":"+i);
		}
	}
}

线程的几种状态：

1、创建状态；

2、就绪状态；

3、运行状态；

4、堵塞状态；

5、死亡状态；

创建线程方法二：

实现runnable接口

子类覆盖接口中的run方法。
通过Thread类创建线程，并将实现了
Runnable接口的子类对象作为参数传递给
Thread类的构造函数。
Thread类对象调用start方法开启线程

Thread是Runnable 的子类

Thread和Runnable 的区别：
Runnable可以共享数据

线程操作常用方法：

取得和设置线程名字getName()

判断线程是否启动isAlive()

sleep(long millis) 线程休眠

join() 强制执行线程

interrupt() 中断线程的某种状态

线程的安全问题：

导致安全问题的出现的原因：

多个线程访问出现延迟。
线程随机性 。

注：线程安全问题在理想状态下，不容易出
现，但一旦出现对软件的影响是非常大
的。

同步（synchronized）

synchronized（对象）
{
需要同步的代码；
}

同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。

同步的前提：

1、同步需要两个或者两个以上的线程。
2、多个线程使用的是同一个锁

未满足这两个条件，不能称其为同步。

同步的弊端：
当线程相当多时，因为每个线程都会去判断
同步上的锁，这是很耗费资源的，无形
中会降低程序的运行效率。

同步函数：

格式：在函数上加上synchronized修饰符

同步函数的锁是this，而同步代码块的锁可以是任意对象

静态同步函数的锁是本类的字节码对象

public void run() {
		if (flag) {
			for (int i = 0; i < 10; i++) {
				//synchronized (this.getClass()) {
				synchronized (GetTickets2.class) {
					if (tickets > 0) {
						try {
							Thread.sleep(500);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()
								+ "卖出" + (tickets--) + "号票"+":同步代码块");
					}
				}
			}
			
		} else {
			for (int i = 0; i < 10; i++) {
				function();
				
			}
		}
	}
	public static synchronized void function() {

		if (tickets > 0) {
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "卖出"
					+ (tickets--) + "号票"+"：同步函数");
			
		}
	}

}

死锁

同步应用过多就有可能会出现死锁，所同步不要使用过分太多

class Lock{
	static final Object objLock1 = new Object();
	static final Object objLock2 = new Object();
}

class DeadLockTest implements Runnable{
	private boolean flag;
	
	public DeadLockTest(boolean flag) {
		this.flag = flag;
	}

	public void run() {
		if(flag){
			while(true){
				synchronized (Lock.objLock1) {
					System.out.println("if中的锁，objLock1");
					synchronized (Lock.objLock2) {
						System.out.println("if中的锁，objLock2");
					}
					
				}
			}
		}
		else{
			while(true){
				synchronized (Lock.objLock2) {
					System.out.println("else中的锁，objLock2");
					synchronized (Lock.objLock1) {
						System.out.println("else中的锁，objLock1");
					}
				}
			}
		}
	}
	
}