线程部分方法、同步锁、单列模式

线程部分方法：

join();//等待该线程死亡
yield();表示该线程愿意产生一些当前使用的处理器
setPriority(1~10);优先级，默认的是5
Thread.currentThread()获得当前正在执行的线程对象
getName();获得名字
setName();修改名字
new Thread(任务，“名字”);
sleep(毫秒);睡眠

同步锁

多线程操作的时候可能会出现安全问题，因为当一个线程正在运算的过程中，另一个线程也参与了，这时就用到了同步锁。
同步锁： synchronized
synchronized(唯一 锁 共享对象){要锁的代码块}

private int count = 100;
while(count>0) {
	synchronized (Tick.class) {//this指的是当前对象，  共享对象
		if(count==0) {
			break;
		}
		try {
			Thread.sleep(100);
			} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"在卖，剩余"+--count);
		}
	}

Lock锁

	private Lock lock;
	private int cont = 100;
	public Ticket(Lock lock) {
	this.lock = lock;
	}
	while(true) {
		lock.lock();
		try {
			if(cont==0) {
				break;
			}
			Thread.sleep(100);
	System.out.println(Thread.currentThread().getName()+"正在卖:"+(--cont)+"张票");
			} catch (InterruptedException e) {
			e.printStackTrace();
			}finally {
			lock.unlock();
		}
}

synchronized和Lock锁的区别 ：
1、synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁
2、用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。
如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了
3、synchronized放弃锁只有两种情况：①线程执行完了同步代码块的内容②发生异常；而lock不同，它可以设定超时时间，也就是说他可以在获取锁时便设定超时时间，如果在你设定的时间内它还没有获取到锁，那么它会放弃获取锁然后响应放弃操作

单列模式

单列模式：为了保证类对象的唯一（只能创建一个实例）
1、对象的构建通过构造器执行来创建
2、不能在其他类中随意创建对象
3、对象的创建在本类中提供一个公共方法

单列集合的创建方式: 懒汉模式存在的问题及处理：多线程调用时容易出现创建多个对象，可以添加锁来处理

• 懒汉模式

class SingLe{
	private static SingLe single;
	
	private SingLe() {}
	public static SingLe getSingLe(){
		
		if(single ==null) {
			//加锁解决了两个线程同时调用，有延迟创建两个对象的问题，
			//但是带来了资源消耗的问题， 在外可以加个判断语句如果是空才执行加锁程序
			synchronized (SingLe.class) {
				if(single ==null) {
					//Thread.sleep(100);
					single = new SingLe();
				}
			}
		}
		return single;
	}
}

饿汉式：
工作中常用的是饿汉式

class SingLe2{
	private static SingLe2 single = new SingLe2();
	private SingLe2() {}
	public static SingLe2 getInstance() {
		return single;
	}
}