黑马程序员--- 学习笔记(第十一天)

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————
多线程
进程是一个正在执行的程序
每一个进程执行都有一个执行的顺序,该顺序就是一个执行路径,或者叫一个控制单元


线程:就是进程中一个独立的控制单元,线程在控制着进程执行


一个进程至少有一个线程控制单元


jvm启动时会有一个进程java.exe,该进程至少有一个线程负责java程序的运行,
而且这个线程运行的代码存在于main方法中,该线程称之为:主线程


扩展:其实更细节的说明jvm,jvm启动不止一个线程,还有负责垃圾回收机制的线程


1.如何在自定义代码,自定义一个线程呢?
通过API的查找,java已经提供了对线程这类事物的描述,就是Thread类


创建线程的第一种方式: 继承Thread类
步骤:
1.定义类,继承Thread
2.复写run方法(将自定义代码存储到该方法,由线程执行)
3.调用线程的start方法
该方法有两个作用:
1.启动线程
2.调用run方法

/*
线程测试 
*/
class Demo1 
{
	public static void main(String [] args){
		  ThreadTest t=new ThreadTest("one"); //创建线程
		  ThreadTest t1=new ThreadTest("two");//创建线程
		  t.start();  //启动
		  t1.start();	//启动
	}
}
/*继承 Thread创建线程*/
class ThreadTest extends Thread
{
	public ThreadTest(String name){
		super(name);
	}
	/*线程run 存储代码的方法*/
	public void run(){
	
		for (int i=0; i<50;i++ )
		{
			System.out.println(Thread.currentThread().getName()+"--------"+i);
		}
	}
}

/*

练习
创建两个线程 与主线程进行交替执行
*/
class Demo2 
{
	public static void main(String[] args) 
	{
		/*创建并启动两个线程与主线程交替运行*/
		   ThreadTest1 t=new ThreadTest1("one ");
		   ThreadTest1 t1=new ThreadTest1("two");
		   t.start();
		   t1.start();
		   for (int i=0; i<50; i++)
		   {
			   System.out.println("main---"+i);
		   }
	}
}
class ThreadTest1   extends  Thread
{
	/*构造函数给线程设置名称*/
	public ThreadTest1(String name){
	   super(name);
	}
	public void run(){
	   for (int i=0;i<50 ;i++ )
	   {   //打印线程名称+i
		   System.out.println(Thread.currentThread().getName()+"---"+i);
	   }
	
	}
}

发现运行结果每个都不同,因为多个线程在获取cpu执行权,cpu执行到谁,谁就运行
明确一点,在某一时刻,只能有一个程序运行(多核除外),cpu在做着快速的切换,以达到看到
是在同时运行的效果


我们可以形象把多线程的运行行为是在互相抢夺cpu执行权


多线程一个特性: 随机性,谁抢到谁就执行,至于执行多长,cpu说的算


为什么要覆盖run方法?
Thread类用于描述线程.该类定义了一个功能,用于存储线程运行的代码,
该存储功能就是run方法,也就是说,Thread类中的run方法用于存储线程要
运行的代码


start()// 开启线程,并执行该线程的run方法
run() //仅仅是对象调用方法,而线程创建但是没启动


原来线程都有自己默认的线程名称
Thread-编号  该编号从0开始


String getName();     //获取名称 返回值String


设置线程名称: super();  或者setName();


static  currentThread(); //获取当前运行的线程 静态方法


IllegaThreadStateException  线程在不合理的状态下运行所产生的异常


局部变量在每个线程都有一份

/*
卖票程序
*/
class Demo3 
{
	public static void main(String[] args) 
	{	
		TicketSale t=new TicketSale("一号窗口");
		TicketSale tt=new TicketSale("二号窗口");
		t.start();
		tt.start();
	}
}
class Test
{
	private static int a=100;
	public void show(){
		System.out.println(a--);
	}
}
/*
卖票线程
*/
class TicketSale extends Thread
{
	private int tic=100;  //可以设置static共享数据,但是生命周期长.可使用第二种解决方法
	public TicketSale(String name){
		super(name);
	}
	public void run(){
		while(true){
				if(tic>0)
				System.out.println(Thread.currentThread().getName()+"售:"+tic--);
		}				
	}
}

创建线程的第二种方法:实现Runnable接口


步骤:
1.定义类实现Runable接口
2.覆盖Runnable接口中的run方法
3.通过Thread建立对象线程对象
4.将Runnable接口的子类对象作为实际参数给Thread类的构造函数
5.调用Thread类的static方法开启线程,调用Runnable口接口子类的run方法


为什么要Runnable子类对象引用,传递给Thread类的构造函数?
因为自定义的run方法所属的对象是Runnable接口的子类对象,所以要让线程去指定对象的run
方法,就必须明确run方法所需对象


实现方式和继承方式有什么区别呢?
实现方式的好处:
避免了单继承的局限性
在定义线程,建立使用实现方式


两种方式区别:
继承Thread:线程代码放在Thread子类的run方法中
实现Runnable:代码放在接口的子类的run方法中


 Thread.sleep(秒数);//使线程暂停执行
会抛InterruptedException 异常,要进行处理.


通过分析发现,打印出了0,-1,-2等错票
多线程的运行出现了安全问题


问题的原因:
当多条语句在操作同一线程共享数据时,一个线程对多条语句只执行了一部分,
还没执行完,另一线程参与进来执行,导致了共享数据的错误


解决方法:
对多条操作共享数据的语句只能让一个线程都执行完,在执行过程中
其他线程不能参与执行


java对于多线程的安全问题提供了专业的解决方法,就是同步代码块
格式如下:
synchronized(对象锁){
       需要同步的语句;
}
对象如同锁.持有锁的线程可以在同步代码块中执行,没有持有的锁的线程,即使获得了
cpu执行权也进不去,因为没有获得锁

/*
卖票程序解决方法
用第二种方式:实现Runnable接口,但是出现了安全隐患

解决安全隐患: java提供了同步代码块 专业的解决方式

*/

class Demo4 
{
	public static void main(String[] args) 
	{
		ThreadImpl tt=new ThreadImpl();
		  Thread t=new Thread(tt,"一号窗口");
		  Thread t1=new Thread(tt,"二号窗口");
		  Thread t2=new Thread(tt,"三号窗口");
		  Thread t3=new Thread(tt,"四号窗口");
		  t.start();
		  t1.start();
		  t2.start();
		  t3.start();
	}	
}
class ThreadImpl implements Runnable
{
	private int tic=100;
	public void run(){
		while(true){
			//同步代码块
			//用字节码文件对象 和用this代表ThreadImpl是一样的 对象如同锁
			//好处:解决多线程安全问题
			//弊端:多个线程都需要判断锁,较为消耗资源
			synchronized(ThreadImpl.class){
				if(tic>0){
					try
					{
						Thread.sleep(10);//假设线程暂停则发生错票问题
					}
					catch (InterruptedException e)
					{
						e.printStackTrace();
					}
					//操作的是同一个资源,tic 
					System.out.println(Thread.currentThread().getName()+"售"+tic--);
				}
			}
		}
	}
}

同步的前提:
1.必须是两个或两个以上线程
2.必须是多个线程使用同一个锁


必须保证同步中只能有一个线程运行


 好处:解决多线程的安全问题,
 弊端:多个线程都需要判断锁,较为消耗资源


 如何找问题?
 1.明确哪些代码是多线程运行代码
 2.明确共享数据
 3.明确的线程哪些语句是操作共享数据的


 一般成员变量都是共享数据


 同步函数

/*同步函数*/
class Demo5 
{
	public static void main(String[] args) 
	{
		Cun cun=new Cun();
		Thread t=new Thread(cun,"张三");
		 Thread tt=new Thread(cun,"李四");
	   t.start();
	   tt.start();
	}
}
class Bank
{
	private int sum;
	/*分析:函数内容都是在操作共享数据,  这时可以用同步函数 */
	public synchronized void add(int money){
			sum+=money;
			try
			{
				Thread.sleep(5); //假设线程发生暂停,其他线程参与,则发生了安全隐患
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
			System.out.println("sum ="+sum);
	}
}
class Cun implements Runnable
{
	private Bank b=new Bank();
	 public void run(){
			for (int i=0; i<3;i++ )
			{
				/*每次存钱 存100*/
				b.add(100);
			}
	}
}

 同步函数使用的是哪一个对象呢?
函数需要被对象调用,那么函数都有一个所属的对象引用,就是this,
所以同步函数使用的的锁是this


通过程序进行验证

/*
一个线程调用同步代码块内容
一个线程调用同步函数的内容

验证同步函数使用的锁是this
*/
class Demo6 
{
	public static void main(String[] args) 
	{
		Test test=new Test();
		Thread t=new Thread(test,"one");
	
		Thread tt=new Thread(test,"two");
		t.start();
		test.b=false; //这样就只会测试show 的
		try
		  {
			Thread.sleep(10);
		  }
		  catch (InterruptedException e)
		  {
			  e.printStackTrace();
		  }
		tt.start();
	}
}
class Test implements Runnable
{
	private  int tic=100;
	boolean b=true;
	Object o=new Object();	//测试锁
	public void run(){
			if(b){
				while(true){
					synchronized(this){//用不同锁测试 得出应该为this 才不会出现安全问题
						if(tic>0){
						  try
						  {
							Thread.sleep(10);
						  }
						  catch (InterruptedException e)
						  {
							  e.printStackTrace();
						  }
						  System.out.println(Thread.currentThread().getName()+"--run--"+tic--);
						}
					}
				}
			}else{
				while(true){
				show();
				}
			}
	}
	public synchronized void show(){
	  if(tic>0){
		  try
		  {
			Thread.sleep(10);
		  }
		  catch (InterruptedException e)
		  {
			  e.printStackTrace();
		  }
	  	 System.out.println(Thread.currentThread().getName()+"-show--"+tic--);
	  }
			
	}
	
}

如果同步函数被静态修饰后,使用的又是什么?
通过运行程序,发现不在是this,因为静态方法中不能有this
静态在进内存时,内存中没有本类对象,但是该类有对象的字节码对象
类名.class  该对象类型是Class


静态同步方法使用的锁是该方法所在的字节码文件对象 类名.class


单例模式
饿汉模式


懒汉模式同步函数与同步代码块实现

/*
单例模式用到的同步函数 同步代码块
*/
class Demo7 
{
	public static void main(String[] args) 
	{
		Single.getInstance();
	}
}
/*
饿汉式
class Single
{
	private Single(){}
	private static Single s=new Single();
	public static Single getInstance(){
		return s;
	}
}

*/
/*
懒汉式 
*/
class Single
{
	private Single(){}
	private static Single s=null;
	/*同步函数抵消,每一次都要判断锁*/
	/*
	public static synchronized Single getInstance(){
		if(s==null)
			s=new Single();
		return s;
	}
	*/
	/*用同步代码块 双重判断稍微高效点*/
	public static Single getInstance(){
			if(s==null){
				synchronized(Single.class){//静态方法的锁是字节码文件对象
					if(s==null){
						s=new Single();
					}
				}	
			}
			return s;
	}
}

死锁

同步中嵌套同步,锁却不同

/*
死锁例子
*/
class Demo8 
{
	public static void main(String[] args) 
	{
		DeadLock d=new DeadLock(new Object(),new Object());
		Thread t=new Thread(d);
		Thread tt=new Thread(d);
		t.start();
		try
		{
			Thread.sleep(10);
		}
		catch (InterruptedException e)
		{
		}
		d.bool=false;
		tt.start();
	}
}
class DeadLock implements Runnable
{
	private Object a; //a锁
	private Object b; //b锁
	public DeadLock (Object a,Object b){
		this.a=a;
		this.b=b;
	}
	boolean bool=true;
	public void run(){
		if(bool){
			while(true)
			  synchronized(a){
					System.out.println("if  locka");
					synchronized(b){
					System.out.println("if  lockb");	
					}
				}
		} else{
			while(true)
			  synchronized(b){
					System.out.println("else  lockb");
					synchronized(a){
					System.out.println("else  locka");	
					}
				}
		}
	}

}

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————