(18)Java学习笔记——多线程01

Thread类

如何创建一个线程：

创建线程方式一：继承Thread类

1/定义一个类继承Thread

2/覆盖Threa类中run方法

3/直接创建Thread的子类对象创建线程

4/调用atart方法开启线程并调用线程的任务run方法执行

class  ThreadDemo01
{
	public static void main(String[] args) 
	{
		Demo p = new Demo("小鱼儿");	//创建Thread的子类对象创建线程
		Demo p1 = new Demo("xiexiecm");
		p.start();	//开启线程，调用run方法
		p1.start();
	}
}

class Demo extends Thread	//创建一个Thread的子类继承Thread
{
	private String name;
	Demo(String name)
	{
		this.name = name;
	}
	public void run()	//创建一个run方法，覆写Thread中的run方法
	{
		for (int x=0;x<100 ;x++ )
		{
			System.out.println(name+"....x="+x);
		}
	}
}

创建线程的目的是为了开启一条执行路径，去运行指定的代码和其他代码实现同时运行。

而运行的指定代码就是这个执行路径的任务。

JVM创建的主线程的任务都定义在主函数中。

Thread类用于描述线程，线程是需要任务的，所以Thread类也对任务的描述。

这个任务就通过Thread类中的run方法来体现，也就是说，run方法就是封装自定义线程运行任务的函数。

run方法中定义的就是线程要运行的任务代码。

开启线程是为了运行指定代码。所以只有继承Thread类，并覆写run方法，将运行的代码定义在run方法中即可。

线程方法

可以通过Thread的getName获取线程的名称 Thread-数字

线程的状态

创建线程方式二：实现Runnable接口

实现步骤：

1/定义类实现Runnable接口

2/覆盖接口中的run方法，将线程的任务代码封装到run方法中

3/通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。

（因为线程的任务都封装在Runnable接口子类对象的run方法中，所以要在线程对象创建时就必须明确要运行的任务。）

4/调用线程对象的start方法开启线程。

Thread(Runnable target)构造函数，target参数——其run方法被调用的对象。

class ThreadDemo02 
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();	//
		Thread t1 = new Thread(d);	//线程对象一建立，必须有任务。用Runnable接口的构造函数传递任务对象（Runnable target）
		Thread t2 = new Thread(d);
		t1.start();
		t2.start();
	}
}

class Demo implements Runnable	//定义类实现Runnable接口
{
	public void run()	//Runnable接口的唯一一个方法run，覆盖
	{
		show();
	}
	public void show()
	{
		for (int x=0;x<20 ;x++ )
		{
			System.out.println(Thread.currentThread().getName()+"...."+x);
		}
	}
}

Runnable的出现仅仅是将线程的任务进行了对象封装。就是用来封装线程对象的。类型是Runnable类型

实现Runnable接口和继承Thread类的区别：（实现Runnable接口的好处）

1/将线程的任务从线程的子类中分离出来，进行了单独的封装。按照面向对象的思想将任务封装成对象。

2/避免了java单继承的局限性。

范例：

/*
需求：四个窗口同时卖100张卖票

*/

class ThreadTest001 
{
	public static void main(String[] args) 
	{
		Ticket t = new Ticket();	//线程任务封装
		Thread t1 = new Thread(t);	//线程对象创建，将对象传递给线程
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);

		t1.start();
		t2.start();
		t3.start();
		t4.start();
		
		/*
		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	//线程任务封装
{
	private int num = 100;

	public void run()
	{
		while(true)
		{
			if (num>0)
			{
				System.out.println(Thread.currentThread().getName()+"....sale...."+num--);
			}
		}
	}
}

线程安全问题产生的原因：

1/多个线程在操作共享的数据

2/操作共享数据的线程代码有多条

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致相称安全问题的产生。

解决思路：

就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程是不可以参与运算的。

必须要当前县城吧这些代码都执行完毕后，其它线程才可以参与运算。

用synchronized同步代码块解决这个问题，

格式：

synchronized(对象） //此对象——理解成一个同步锁。类似开关，第一个线程进来后设置了切换，告诉了第二个线程不能进来。——同步锁

//（理解成火车上的卫生间  有人/无人）

{

需要被同步的代码；

}

同步的好处：解决了线程的安全问题

同步的弊端：相对降低了效率，因为同步外的线程都会判断同步锁。

同步的前提：同步中必须有多个线程并使用同一个锁。

同步的表现形式：

1/同步代码块

class Bank
{
	private int sum;
	private Object obj = new Object();
	public void add(int num)
	{
		synchronized(obj)	//同步代码块 （obj）同步锁
		{
			sum = sum + sum;
			System.out.println("sum="+sum);
		}
	

2/同步函数

同步函数用的锁！！同步函数使用的锁是this，静态方法的锁不是this

class Bank
{
	private int sum;
	private Object obj = new Object();
	public synchronized void add(int num)	//同步函数
	{
			sum = sum + sum;
			System.out.println("sum="+sum);
	}
}

同步函数和同步代码块的区别：

1/同步函数的锁是固定的this

2/同步代码块的锁是任意的对象

静态同步函数使用的锁就是该函数所属的字节码文件对象，可以用getclass方法获取，也可以用当前  类名 . class 表示

————————————————————————————————————————

死锁

常见情景之一：同步的嵌套

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

	public void run()
	{
		if (flag)
		{
			synchronized(MyLock.locka)	//线程一拿了a锁
			{
				System.out.println("if	locka....");
				synchronized(MyLock.lockb)	//线程一想拿b锁，但是被线程二拿了
				{
					System.out.println("if	lockb....");

				}
			}
		}
		else
		{
			synchronized(MyLock.lockb)	//线程二拿了b锁，
			{
				System.out.println("else	lockb.....");
				synchronized(MyLock.locka)	//线程二想拿b锁，但是被线程一拿了
				{
					System.out.println("else	locka....");
				}
			}

		}
	}
}

class MyLock
{
	public static final Object locka = new Object();
	public static final Object lockb = new Object();
}

class DeadLockTest 
{
	public static void main(String[] args) 
	{
		Test a = new Test(true);
		Test b = new Test(false);

		Thread t1 = new Thread(a);	//建立两个线程
		Thread t2 = new Thread(b);
		t1.start();
		t2.start();
	}
}