多线程（一）

 

一、进程

进程：是一个正在执行中的程序。

       每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

二、线程

线程：就是进程中的一个独立的控制单元。

         线程在控制着进程的执行。  一个进程中至少有一个线程。

 

Java VM 启动的时候会有一个进程java.exe。

 

该进程中至少一个线程负责java程序的执行。而且这个纯种运行的代码存在于main方法中。该线程称之为主线程。

 

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

三、多线程存在的意义。

四、线程的创建方式。

如何自定义的代码中，自定义一个纯线程呢？

通过对API的查找，Java已经提供了对线程这类事物的描述。就是Thread类。

1、创建线程的第一种方式：继承Thread类。

步骤：

（1）    定义类继承Thread。

（2）    复写Thread类中的run方法。

       为什么要覆盖run方法呢？

            Thread类用于描述线程。

            该类定义了一个功能，用于存储纯种要运行的代码。该存储功能就是run方法。也就是说Thread类中的run方法，用于存储线程要运行的代码。

（3）    调用线程的start方法，

           该方法有两个作用：启动线程，调用run方法。

实现例子：

 class Demo extends Thread
{
	public void run(){
		System.out.println("这是一个新的线程");
	}
};

class ThreadDemo 
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		d.start();
	}
}

2、创建线程的第二种方式：实现Runable接口,一般是多个线程共享一个数据源使用的方式。

 

步骤：

（1）定义类实现Runnable接口

（2）覆盖Runnable接口中的run方法。

        将线程要运行的代码存放在该run方法中。

（3）通过Thread类建立线程对象。

（4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

        为什么要将Runnable接口的子类对象传递给Thread的构造函数。

               因为，自定义的run方法所属的对象是Runnable接口子类对象。

               所以要让纯种去指定指定对象的run方法。就必须明确该run方法所属对象。

 

（5）调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

   

 

 

3、实现方式和继承方式有什么别呢？

实现方式好处：避免了单继承的局限性。在定义线程时，建立使用实现方式。

 

两种方式区别：

继承Thread：线程代码存放Thread子类run方法中。

实现Runnable：线程代码存在接口的子类的run方法。

五、多线程的特性。

1、多线程的运行状态图

2、多线程的运行出现了安全问题。

 

问题的原因：

    当多条毫不语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，

        还没有执行完别一个线程参与进来执行。共享数据的错误。

 

解决办法：

    对多条操作共享数据的语句，只能让一个纯种都执行完。在执行过程中，其它线程不参与执行。

 

        Java对于多线程的安全问题提供了专业的解决方式。

 

        就是同步代码块。

        synchronized(对象)

        {

                 需要被同步的代码

        }

        对象如同锁，持有锁的纯种可以在同步中执行。

        没有持有锁的线程即便获取cpu的执行权，也进行不去，因为没有获取锁。

 

 火车上的卫生间---经典的例子。

 

3、同步的前提：

 （1）必须要有两个或者两个以上的线程。

 （2）必须是多个线程使用同一个锁。

 

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

 

 好处：解决了多纯种的安全问题。

 

 弊端：多个线程需要判断，较说为消耗资源

 

4、同步中的锁问题

(1)  例子

/*
同步函数用的是哪一个锁呢？
函数需要被对象调用，那么函数都有一个所属对象引用。就是thi.
所以同步函数使用的锁是this.

通过该程序进行验证。

使用两个纯种来买票。
一个线程在同步代码中。
一个线程在同步函数中。
在都执行买票动作。


如果共享同一数据的两个代码不在同一个锁就是会出现安全问题。

如下面的例子run方法里面用的锁的Object对象类型的锁，而函数
show用的是this（就是本类的对象）锁。两个不在同一个锁里，
程序就出现0，这是不正确的。

只要把Object类型的对象该为本类的对象(this)程序就正确了。
*/

class Ticket implements Runnable
{
	private int tick = 100;
	Object obj = new Object();
	boolean flag = true;
	public void run(){
		if(flag)
		{
			while (true)
		    {
		    	synchronized(obj){
					if(tick>0){
						try
						{
							Thread.sleep(10);
						}
						catch (Exception e)
						{
						}
						System.out.println(Thread.currentThread().getName()+"...sale : "+tick--);
					}
				}
		    }
		}
		while (true)
		{
			this.show();
		}
		
	}

	public synchronized void show(){
		if(tick>0){
			try
			{
				Thread.sleep(10);
			}
			catch (Exception e)
			{
			}
	       	System.out.println(Thread.currentThread().getName()+"...show : "+tick--);
		}
		
	}
};


class ThisLockDemo
{
	public static void main(String[] args) 
	{
		Ticket c = new Ticket();
		Thread t1 = new Thread(c);
		Thread t2 = new Thread(c);

		t1.start();
  /*
  问题在这里：可能出现的情况
  主线程运行到这里，t1线程被开启了，拥有了执行权，但它却没有被执行，
  主线程继续往下执行，flag 的值就会变为 false ，在执行run方法 的时候
  就只执行else这不是我们要的结果。
       如果想要看到它们两个都执行的结果，只要把主线休息一会让t1执行就可以了
  */    
	    try
	    {
	    	Thread.sleep(10);//这里就是让请线程休息了10毫秒
	    }
	    catch (Exception e)
	    {
	    }
		c.flag = false;
		t2.start();
	}
}

 （2）静态方法例子

 

/*
如果同步函数被静态修饰后，使用的锁是什么呢？

通过验证，发现不在是this。因为静态方法中也不可以定义this。

静态进内存是，内存中没有本类对象，但一定有该类对应的字节码文件对象。
类名.class 该对象的类型是Class

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

*/

class Ticket implements Runnable
{
	private static int tick = 100;
	Object obj = new Object();
	boolean flag = true;
	public void run(){
		if(flag)
		{
			while (true)
		    {
		    	synchronized(Ticket.class){
					if(tick>0){
						try
						{
							Thread.sleep(10);
						}
						catch (Exception e)
						{
						}
						System.out.println(Thread.currentThread().getName()+"...sale : "+tick--);
					}
				}
		    }
		}
		while (true)
		{
			this.show();
		}
		
	}

	public static synchronized void show(){
		if(tick>0){
			try
			{
				Thread.sleep(10);
			}
			catch (Exception e)
			{
			}
	       	System.out.println(Thread.currentThread().getName()+"...show : "+tick--);
		}
		
	}
};


class taticMenthodDemo
{
	public static void main(String[] args) 
	{
		Ticket c = new Ticket();
		Thread t1 = new Thread(c);
		Thread t2 = new Thread(c);

		t1.start();
       try
	    {
	    	Thread.sleep(10);//这里就是让请线程休息了10毫秒
	    }
	    catch (Exception e)
	    {
	    }

		c.flag = false;
		t2.start();
	}
}

3、死锁。

  就是两个的同步代码,所属的锁不一样，互相调用的对方，担对方都正忙着工作，所以拒绝了被调用。

 

例子：

class Ticket implements Runnable
{
	private int tick = 500;
	Object obj = new Object();
	boolean flag = true;
	public void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(obj)
				{
					show();
				}
			}
		}else
			while(true)
			   show();
	}

	public synchronized void show()
	{
		synchronized(obj)
		{
			if(tick>0)
			{
				try
				{
					Thread.sleep(10);
				}
				catch(Exception e)
				{
				}
				System.out.println(Thread.currentThread().getName()+".....show : "+tick--);
			}
		}
		
	}
};
class  DeadLockDemo
{
	public static void main(String[] args) 
	{
		Ticket t = new Ticket();

		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		try
		{
			Thread.sleep(10);
		}
		catch (Exception e1)
		{
		}
		t.flag = false;
		t2.start();
	}
}