java基础（多线程）

/*
进程： 一个正在执行中的程序（每一个进程执行都有一个执行路径，或者叫一个控制单元）

线程：进程中的一个独立的控制单元（线程控制着进程执行，一个进程至少有一个线程）

在自定义代码中自定义一个线程
1.继承Thread类：
步骤：
	定义类继承Thread方法
	复写Thread类中的run方法(存储要线程运行的代码)
	调用线程的start方法（该方法1.启动线程2.调用run方法）

2.继承Runnable接口（避免单继承的局限性，  ）
步骤：
	定义类实现Runnable接口
	覆盖Runnable接口中的run方法（存储要线程运行的方法）
	通过Thread类建立线程对象
将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数（自定义的run方法所属的对象是Runnable接口的子类对象
	所以要让线程去指定对象的run方法，就必须明确该run方法所属对象）
	调用start方法开启线程并调用Runnable接口子类的run方法。

线程有默认名（Thread-编号，从0开始）

static Thread currentThread（）；获取当前线程对象。
getName（）；获取线程名称。

设置线程名称：setName或者构造函数 

区别：
Thread：线程代码存放在 Thread子类的run方法中
Runnable：线程代码存放在接口的子类的run方法中

线程的安全性问题（模拟多条语句操作同一个线程共享数据时，一个线程执行过程中，还未完成，另一个线程取得执行权，导致共享数据错误）
解决：让一个线程执行完才让下一线程执行
方案：同步代码块
synchronized（对象）对象如同锁。持有锁的线程可以在同步中执行，没持有锁的线程即使获取cpu执行权也进不去，必须获取锁。
{
	需要同步的代码块（需要共享数据的代码）
}
同步前提：必须要有两个或者两个以上的线程；必须是多个线程使用同一个锁，必须保证只有一个线程在同步

同步函数
1.找到多线程运行的代码
 2.找到共享数据
 3.找到多线程中操作共享数据的语句
 */
/*
class Demo extends Thread
{
	//private String name;
	Demo(String name)
	{
		//this.name=name;
		 super(name);
	}
	public void run()
	{ 
		for(int x=0;x<60;x++)
		{
			System.out.println((Thread.currentThread()==this)+this.getName()+"d"+x);
		}
	}
}

public class Ly {
	public static void main(String[] args)
	{
		Demo d = new Demo("t");
		d.start();
		//d.run(）仅仅是对象调用方法，而线程创建了，并未运行
		for(int x=0;x<60;x++)
		{
			System.out.println("t"+x);
		}
	}

}
*/

/*
卖票：多个窗口买票

class Ticket extends Thread
{
	
	
	private static int tick =100;//
	public void run()
	{
		while(true)
		{
			if(tick>0)
			System.out.println("...rest:"+tick--);
		}
	}
}
 

class Ly
{
	public static void main(String[] args)
	{
		Ticket t1=new Ticket();
		Ticket t2=new Ticket();
		Ticket t3=new Ticket();
		Ticket t4=new Ticket();
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		
		
	}
}
*/
/*
同步：
class Ticket implements Runnable//继承Runnable并不是线程
{
	private int tick=100;
	Object obj=new Object();
	public void run()
	{
		while(true)
		{
			synchronized(obj)
			{
			if(tick>0)
			{	try
			{
				Thread.sleep(10);//模拟线程问题
			}
			catch(Exception e)
			{
				
			}
				System.out.println(Thread.currentThread().getName()+"   rest"+tick--);
			}
			}
		}
	}
}

class Ly
{
	public static void main(String[] args)
	{
		Ticket t=new Ticket();
		Thread d1 = new Thread(t);
		Thread d2 = new Thread(t);
		Thread d3 = new Thread(t);
		Thread d4 = new Thread(t);
		d1.start();
		d2.start();
		d3.start();
		d4.start();
	}
}

*/
/*
 *同步函数：(将要同步函数封装起来)
 银行：
 两个储户分别存300员，每次存100，存三次
 目的：解决安全性问题
 如何找到问题：
 1.找到多线程运行的代码
 2.找到共享数据
 3.找到多线程中操作共享数据的语句
 用this锁
 
 如果同步函数用static修饰，锁不是this，因为static修饰的不能用this。
 静态的同步方法使用的锁是该方法所在的字节文件对象。 类名。class
 */
/*
class Bank 
{
	private int sum;
	public synchronized void add(int n)//锁时用的this
	{
		sum=sum+n;
		try
		{
			Thread.sleep(10);
		}
		catch(Exception e)
		{
			
		}
		System.out.println("sum="+sum);
	}
}

class Cus implements Runnable
{
	private Bank b=new Bank();
	public void run()
	{
		for(int x=0;x<3;x++)
		{
			b.add(100);
		}
	}
}

class Ly
{
	public static void main(String[] args)
	{
		Cus c = new Cus();
		Thread t1=new Thread(c);
		Thread t2=new Thread(c);
		
		t1.start();
		t2.start();
		
		
	}
}
*/