java基础——多线程



多线程

一、多线程的概述

在这之前，先看一看进程和线程的概念，

进程：正在进行中的程序。

线程：就是进程中一个负责执行的控制单元（执行路径）。

一个进程中可以多执行路径，就是多线程。一个进程中至少有一个线程。

多线程的目的：开启多个线程是为了同时运行多部分代码。

多线程的好处：解决了多部分同时运行的问题。

多线程的弊端：线程太多回收效率低。

二、创建多线程的方式

创建多线程有两种方式，第一是继承Thread类，第二是实现Runnable接口。

1.继承Thread

class A extends Thread
{
	A(Srting name)//这个方法可以给线程命名,如果要命名就写
	{
	super(name)
	}
	public void run{
	//要实现的代码
	System.out.println(Thread.currentThread().getName()+this.name+"生产啦.");
	}
}
class Test
{
	public static void main(Strting[] args)
	{
		A a =new A("线程1");\
		a.start();
		//要启动多少个线程,就创建多少个对象.并start.
	}
}

这种方式是，继承Thread后重写run方法，把需要实现的代码放进器，然后通过创建这个类的对象，调用它的start方法启动线程。

2.实现Runnable接口

class B implments Runnable
{
	public run{//具体代码实现}
}
class Test 
{
	public static void main(Strting[] args)
	{
		B a =new B();
		Thread t = new Thread(a);
		t.start();
		//要启动多少个线程,就创建多少个对象.并start.
	}

}

这种方式是，让一个类实现Runnable接口，并重写run方法，然后新建一个Thread线程，并把刚才的类的对象传递给Thread，并调用Thread的start方法开启线程。

总的来说：

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

实现Runnable：线程代码存放在接口的子类的run方法中。这种方式避免了单继承的局限性。

三、线程的状态

线程的状态主要有：

被创建：等待启动，调用start启动。

运行状态：具有执行资格和执行权。

阻塞状态：具有执行资格，但没有执行权。

冻结状态：失去执行资格和执行权，如遇到sleep和wait后，就会失去执行资格和执行权，知道sleep方法时间到了，或是调用notify，才获得执行资格，变为阻塞状态。

消亡状态：run方法结束或是调用stop方法。

各个状态如下图：

四、线程同步

同步synchronized就是修饰一个代码块或方法，使里面只能有一个线程在执行。

当我们用多线程操作同一数据时，由于线程执行的不确定性，可能会出现多个线程重复操作同一个数据。比如，每次生产一个产品就要出库一个产品，如果，线程在生产时暂停了，那么进来一个新线程，同时其又启动了，这时就会产生两个产品，而没有出库，这就产生了安全隐患。如果用了同步，那么外面的线程智能等里面的线程执行完后，才能进来，这样就避免了这种不安全的情况产生。

例如，一个多窗口买票的程序：

class SellDemo implements Runnable{  
    private int num = 50;  
    public void run() {  
        for (int i = 0; i < 200; i++) {  
                if(num > 0){   
                    try {  
                    //因为它不可以直接调用getName()方法，所以必须要获取当前线程。  
                        Thread.sleep(10);  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                System.out.println(Thread.currentThread().getName()+"卖出第"+num--+"张票！");  
            }  
        }  
    }  
}  
public class Demo3 {  
    public static void main(String[] args) {  
        SellDemo s = new SellDemo();  
        new Thread(s,"A").start();  
        new Thread(s,"B").start();  
        new Thread(s,"C").start();  
    }  
} 

这种情况下，可能会产生负数，也就是线程不同步的，如果不想出现负数，并且是线程同步的，这就需要加上synchronzed了。

它的用法如下：

修饰方法:在返回值前加snychronized

修饰代码:snychronized(对象){同步代码}

给买票的程序加上同步代码块，如下：

/*	
给卖票程序示例加上同步代码块。
*/
class Ticket implements Runnable
{
	private int tick=100;
	Object obj = new Object();
	public void run()
	{
		while(true)
		{
			//给程序加同步，即锁
			synchronized(obj)
			{
				if(tick>0)
				{
					try
					{	
						//使用线程中的sleep方法，模拟线程出现的安全问题
						//因为sleep方法有异常声明，所以这里要对其进行处理
						Thread.sleep(10);
					}
					catch (Exception e)
					{
					}
					//显示线程名及余票数
					System.out.println(Thread.currentThread().getName()+"..tick="+tick--);
				}
			}	
		}
	}
}

再给买票的程序使用同步函数，如下：

class Ticket implements Runnable
{
	private int tick=100;
	Object obj = new Object();
	public void run()
	{
		while(true)
		{
			show();
		}
	}
  //直接在函数上用synchronized修饰即可实现同步
public synchronized void show()
{
		if(tick>0)
	    {
		try
		{	
			//使用线程中的sleep方法，模拟线程出现的安全问题
			//因为sleep方法有异常声明，所以这里要对其进行处理
			Thread.sleep(10);
		}
		catch (Exception e)
		{
		}
		//显示线程名及余票数
		System.out.println(Thread.currentThread().getName()+"..tick="+tick--);
	}
    }	
}

此时，函数都有一个所属对象的引用，就是this。同步函数使用的锁也是this。

现在总结一下同步，

可以看到同步的前提：

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

2.必须是多个线程使用同一把锁。

同步的利弊：

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

弊端：多线程需要判断锁，比较耗费资源。

接着就是如何寻找多线程中的安全问题：

1.明确哪些代码是多线程运行代码。

2.明确共享数据。

3.明确多线程运行代码中哪些语句是操作共享数据的。

在静态函数中的同步方式

下面是一个饿汉式的单例模式：

/*
加同步的单例设计模式————懒汉式
*/
class Single
{
	private static Single s = null;
	private Single(){}
	public static void getInstance()
	{
		if(s==null)
		{
			synchronized(Single.class)
			{
				if(s==null)
					s = new Single();
			}
		}
		return s;
	}
}

我们发现，此时使用的锁不再是this，而是类名.class，这是因为静态方法中本身不能定义this，静态在进入内存时，内存中没有本类对象，但是一定有该类的字节码文件对象。

五、线程间通信

    具体的内容见我的另一篇博客，生产者与消费者问题。下面简要总结一下线程间的通信规则：

    snychronized一般与方法wait()等待notify() 唤醒最先等待的那个线程 notifyAll()唤醒所有 ,这三个方法都在Object类中,而Object是所有类的超类.

wait()方法会抛出一个异常,所以要用到try({}catch(){};

1.5以后的替换用法以:Lock

在snychronized体系中,等待唤醒其是一种普及操作,notify 与 wait(),没有具体联系,是独立的,只与线程偶合性高,唤醒是看哪个线程先等待,由线程属性决定

而Lock,体系中,把wait() notify() notifyAll()封装为一个Condition对象,(一个Lock可以对应多个Condition对象,)那么同时等待与唤醒就有了对应关系,就是说我的等待只能我唤醒,其就具有了从属关系,每当唤醒与我同一个对象里的等待,与线程等待先后没有关系,那么便可以通过等待与唤醒放置位置的不同,灵活的控制不同线程的等待与唤醒。

六、线程的一些常用方法

setDaemon(boolean):

将线程标记为后台线程，后台线程和前台线程一样，开启，一样抢执行权运行，当参数boolean为true时标记为守护线程.

必须在线程启动前标记,也就是先t.setDaermon(true);然后再t.start(); ---t代表一个线程

        只有在结束时，有区别，当前台线程都运行结束后，后台线程会自动结束(不管后台线程是否运行结束,当然也可以后台线程先结束,前台线程还继续.)。且当现有进程都为守护线程时,java虚拟机退出,.程序结束

 join():

是等待该线程结束。当A线程执行到了B的.join方法时，A就会处于冻结状态。

注意:join处于哪个线程中,就对哪个线程起作用.

 A什么时候运行呢？当B运行结束后，A就会具备运行资格，继续运行。

用于:加入线程，可以完成对某个线程的临时加入执行。

Priority()优先级 优先级1---10

获得线程的优先级:线程名.getPriority()

设置线程的优先级:线程名.setPriority(1~10)

yield()方法 让线程的优先级相对平均一些

格式:Thread.yield();