java中多线程笔记（二）

多线程安全问题：

当一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。

 

涉及到两个因素：

1，多个线程在操作共享数据。

2，有多条语句对共享数据进行运算。

原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。

 

解决安全问题的原理：

只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。

 

如何进行多句操作共享数据代码的封装呢？

java中提供了一个解决方式：就是同步代码块。

格式：

synchronized(对象) { 

    需要被同步的代码；

}

哪些代码对共享的数据操作了，就可以将这些代码放入其中。

class Ticket implements Runnable
{
	private  int tick = 1000;
	public void run()
	{
		while(true)
		{
			synchronized(new Object())
			{
				if(tick>0)
				{
			       System.out.println(this.getName()+"....sale : "+ tick);
				}
			}
		}
	}
}


class  TicketDemo2
{
	public static void main(String[] args) 
	{

		Ticket t = new Ticket();

		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		t2.start();
	}
}

第二种方法为使用同步函数，就是将同步关键字定义在函数上，让函数具备了同步性。其使用的对象锁为this对象。

如果同步函数被static修饰时，这时的同步用的是哪个锁呢？

静态函数在加载时所属于类，这时没有该类产生的对象，但是该类的字节码文件加载进内存就已经被封装成了对象，这个对象就是该类的字节码文件对象。

所以静态加载时，只有一个对象存在，那么静态同步函数就使用的这个对象。

这个对象就是 类名.class

好处：解决了线程安全问题。

弊端：相对降低性能，因为判断锁需要消耗资源，产生了死锁。

线程同步在单例模式下的应用：

//饿汉式。
class Single
{
	private static final Single s = new Single();
	private Single(){}
	public static Single getInstance()
	{
		return s;
	}
}
//懒汉式
class Single
{
	private static Single s = null;
	private Single(){}
	public static  Single getInstance()
	{
		if(s==null)
		{
			synchronized(Single.class)
			{
			if(s==null)
			s = new Single();
			}
		}
		return s;
	}
}

懒汉式：延迟加载方式。

当多线程访问懒汉式时，因为懒汉式的方法内对共性数据进行多条语句的操作。所以容易出现线程安全问题。为了解决，加入同步机制，解决安全问题。但是却带来了效率降低。为了效率问题，通过双重判断的形式解决。

线程间通信：思路：多个线程在操作同一个资源，但是操作的动作却不一样。

1：将资源封装成对象。

2：将线程执行的任务(任务其实就是run方法。)也封装成对象。

 

等待唤醒机制：其中使用到以下方法：

wait:将同步中的线程处于冻结状态。释放了执行权，释放了资格。同时将线程对象存储到线程池中。

notify：唤醒线程池中某一个等待线程。

notifyAll:唤醒的是线程池中的所有线程。

 

注意：

1：这些方法都需要定义在同步中。

2：因为这些方法必须要标示所属的锁。

    你要知道 A锁上的线程被wait了,那这个线程就相当于处于A锁的线程池中，只能A锁的notify唤醒。

3：这三个方法都定义在Object类中。为什么操作线程的方法定义在Object类中？

    因为这三个方法都需要定义同步内，并标示所属的同步锁，既然被锁调用，而锁又可以是任意对象，那么能被任意对象调用的方法一定定义在Object类中。

 

wait和sleep区别： 分析这两个方法：从执行权和锁上来分析：

wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的notify或者notifyAll来唤醒。线程会释放执行权，而且线程会释放锁。

sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。线程会释放执行权，但不是不释放锁。

 

线程的停止：通过stop方法就可以停止线程。但是这个方式过时了。

停止线程：原理就是：让线程运行的代码结束，也就是结束run方法。一般run方法里肯定定义循环。所以只要结束循环即可。

第一种方式：定义循环的结束标记。

第二种方式：如果线程处于了冻结状态，是不可能读到标记的，这时就需要通过Thread类中的interrupt方法，将其冻结状态强制清除。让线程恢复具备执行资格的状态，让线程可以读到标记，并结束。