黑马程序员----java基础：多线程

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

　　如果一次只完成一个事情，还是比较容易实现的，但事实上很多事情都是同时执行的，java为了模拟这种状态，引入了线程机制。

当程序同时完成多个事情时，就是所谓的多线程程序。

　　在一个时刻，单核的cpu只能运行一个程序。而我们看到的同时运行效果，只是cpu在多个进程间做着快速的随机切换动作。

　　所以说多线程解决了多部分同时运行的问题，但是线程太多的话肯定会影响效率。

　　首先老规矩一张图来展现我们本次要介绍的内容：

 一、实现方式

 实现线程的方式一共有两种---继承Thread类和实现Runnable接口。

1、继承Thread类。

        a、定义类继承Thread。

        b、复写Thread中的run方法。

        c、创建定义类的实例对象。

        d、调用start方法启动线程。

 

class TestThread extends Thread            // a、定义类继承Thread。
{ public void run()                    //b、复写Thread中的run方法。
 { for (int x = 0; x < 50 ;x++ ) { System.out.println(Thread.currentThread().getName()+"......"+x); } } } class Demo { public static void main(String[] args) { TestThread t1= new TestThread();//c、创建定义类的实例对象。
        TestThread t2= new TestThread(); t1.start(); //d、调用start方法启动线程。
 t2.start(); } } 

2、实现runnable接口

 　　a、定义类实现Runnable的接口。

        b、覆盖Runnable接口中的run方法。

        c、通过Thread类创建线程对象。

        d、调用start方法启动线程。

class TestThread implements Runnable　　　　　　　　　　　　//a、定义类实现Runnable的接口。
{
	public void run()				// b、覆盖Runnable接口中的run方法。
	{
		for (int x = 0; x < 50 ;x++ )
		{
			System.out.println(Thread.currentThread()+"++++++"+x);
		}
	}
}
class Demo
{
	public static void main(String[] args) 
	{

		TestThread d = new TestThread();	
		Thread t1 = new Thread(d);
		Thread t2 = new Thread(d);		//c、通过Thread类创建线程对象。
		t1.start();			　　　　 //d、调用start方法启动线程。
		t2.start();
	}
}

3、实现Runnable接口的优势

　　实际开发中，我们经常使用第二种方式做多线程，它的优势在于

　　a、避免了按照面向对象的思想将任务封装成对象。

　　b、避免了java单继承的局限性。

 

 

 

 二、线程的生命周期

线程具有生命周期，其各个生命周期的关系如下图。

 

 

 

 

 三、线程安全

　　实际开发中，使用多线程的情况有很多，比如火车站售票系统，当有多个线程做取票动作时，假设此时只有一张票，一线程将票售出，此时二线程完成了判断是否有票动作，并得出票数大于0结论。此时执行售票就会产生负数。

1、安全问题产生的原因

　　a、多个线程在操纵共享数据

　　b、操纵共享数据的代码有多条。

2、解决办法--同步

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

　　a、同步代码块

　　

synchronized(obj) {
　　//需要同步的代码 }

　　b、同步函数

public synchronized void show() { //需要同步的代码
}     

3、同步函数和同步代码块的区别

　　同步函数的锁是this

　　同步代码块的锁是任意的（也可以是this)

　　实际开发中建议用同步代码块。

4、同步的利弊

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

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

 5、静态函数代码块

　　如果同步函数被静态修饰后，使用的锁是什么呢？设计模式中的单例模式给大家展示。

//懒汉式
class Single { private static Single s = null; private Single(){} public static Single getInstance() { if(s == null) { synchronized(Single.class)    //静态方法写---类名.class
 { if(s==null) s = new Single(); } } return s; } }

 

 四、线程间通信

 线程间的通信其实就是多个线程共享同一个资源。

class ResorceDemo { public static void main(String[] args) { Resorce r = new Resorce(); Input in = new Input(r); Output out = new Output(r); Thread t1 = new Thread(in); Thread t2 = new Thread(out); t1.start(); t2.start(); } } class Resorce //定义一个资源
{ String name; String sex; boolean flag = false; } class Input implements Runnable //写入资源
{ Resorce r; Input(Resorce r) { this.r = r; } public void run()//复写run方法
 { int x = 0;//x相当于一个标志.
        while (true) { synchronized(r) { if (r.flag == true) { try { r.wait(); } catch (InterruptedException e) { } } else { if (x==0) { r.name = "mike"; r.sex = "nan"; } else { r.name = "傻妞"; r.sex = "妞妞妞妞i牛i牛ii牛"; } r.flag = true; r.notify();//唤醒
 } x = (x+1)%2;//x在0和1之间相互交替.
 } } } } class Output implements Runnable //读取资源
{ Resorce r; Output(Resorce r) { this.r = r; } public void run() { while (true)//无限循环
 { synchronized(r) { if (r.flag == false) { try { r.wait(); } catch (InterruptedException e) { } } else { System.out.println(r.name + "..."+r.sex); r.flag = false; r.notify(); } } } } }

 

 

 五、常见操作方法

1，wait(): 让线程处于冻结状态，被wait的线程会被存储到线程池中。
2，notify():唤醒线程池中一个线程(任意).
3，notifyAll():唤醒线程池中的所有线程。
4，setPriority（）：设置优先级
5，yield（）：暂停当前线程，让其他线程执行。

 

当然，这些常见的操作方法在API中都可以查到，这不是我要说的重点，下面来对这些方法做一下比较。

 

（1）wait 和 sleep 区别？

　　1，wait可以指定时间也可以不指定。    sleep必须指定时间。

　　2，在同步中时，对cpu的执行权和锁的处理不同。  wait：释放执行权，释放锁。  sleep:释放执行权，不释放锁。

(2)wait(),notify(),notifyAll(),用来操作线程为什么定义在了Object类中？

                a，这些方法存在与同步中。

                b，使用这些方法时必须要标识所属的同步的锁。同一个锁上wait的线程，只可以被同一个锁上的notify唤醒。

                c，锁可以是任意对象，所以任意对象调用的方法一定定义Object类中。

 六、总结

 多线程本身也是比较复杂的问题，要完全理解它还需要时间，所谓孰能生巧，这些知识还是要多看多练多去实践才能真正掌握。