Java 多线程

1. 基本概念：程序 - 进程 - 线程

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。

　　如：运行中的QQ，运行中的MP3播放器

　　程序是静态的，进程是动态的

线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

　　若一个程序可同一时间执行多个线程，就是支持多线程的

2. 多线程的创建和启动

创建多线程的第一种方式：继承java.lang.Thread类

//创建一个子线程，完成1-100之间自然数的输出。同样地，主线程执行同样的操作
//1.创建一个继承于Thread的子类
class SubThread extends Thread{
	//2.重写Thread类的run()方法.方法内实现此子线程要完成的功能
	public void run(){
		for(int i = 1;i <= 100;i++){
			System.out.println(Thread.currentThread().getName() +":" + i);
		}
	}
}
public class TestThread {
	public static void main(String[] args) {
		//3.创建子类的对象
		SubThread st1 = new SubThread();
		SubThread st2 = new SubThread();
		//4.调用线程的start()：启动此线程；调用相应的run()方法
		//一个线程只能够执行一次start()
		//不能通过Thread实现类对象的run()去启动一个线程
		st1.start();
		st2.start();
		
		for(int i = 1;i <= 100;i++){
			System.out.println(Thread.currentThread().getName() +":" + i);
		}
	}
}

/* Thread的常用方法：
 * 1.start()：启动线程并执行相应的run()方法
 * 2.run():子线程要执行的代码放入run()方法中
 * 3.currentThread()：静态的，调取当前的线程
 * 4.getName():获取此线程的名字
 * 5.setName():设置此线程的名字
 * 6.yield():调用此方法的线程释放当前CPU的执行权
 * 7.join():在A线程中调用B线程的join()方法，表示：当执行到此方法，A线程停止执行，直至B线程执行完毕，A线程再接着join()之后的代码执行
 * 8.isAlive():判断当前线程是否还存活
 * 9.sleep(long l):显式的让当前线程睡眠l毫秒
 * 10.线程通信：wait()   notify()  notifyAll()
 * 
 * 设置线程的优先级
 * getPriority() ：返回线程优先值 
   setPriority(int newPriority) ：改变线程的优先级
 */

 创建匿名线程：

new Thread("thread--0"){ //线程名可以省略
            public void run(){
                for(int i = 0; i < 100; i++){
                    if(i%2 == 0){
                        System.out.println(Thread.currentThread().getName() + ": " + i);
                    }
                }
            }
        }.start();

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

//1.创建一个实现了Runnable接口的类
class PrintNum1 implements Runnable {
	//2.实现接口的抽象方法
	public void run() {
		// 子线程执行的代码
		for (int i = 1; i <= 100; i++) 
			if (i % 2 == 0) 
				System.out.println(Thread.currentThread().getName() + ":" + i);	
	}
}
public class TestThread1 {
	public static void main(String[] args) {
		//3.创建一个Runnable接口实现类的对象
		PrintNum1 p = new PrintNum1();
		//要想启动一个多线程，必须调用start()
		//4.将此对象作为形参传递给Thread类的构造器中，创建Thread类的对象，此对象即为一个线程
		Thread t1 = new Thread(p);
		//5.调用start()方法：启动线程并执行run()
		t1.start();//启动线程；执行Thread对象生成时构造器形参的对象的run()方法。
		
		//再创建一个线程
		Thread t2 = new Thread(p);
		t2.start();
	}
}

 继承方式和实现方式的联系与区别

　　 1.联系：public class Thread implements Runnable

　　 2.哪个方式好？实现的方式优于继承的方式

　　　　1）避免了单继承的局限性

　　　　2）多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

线程的调度

Java的调度方法

　　同优先级线程组成先进先出队列（先到先服务），使用时间片策略

　　对高优先级，使用优先调度的抢占式策略

线程的优先级

　　线程的优先级控制： MAX_PRIORITY（10）;    MIN _PRIORITY （1）;  NORM_PRIORITY （5）;

3. 线程的生命周期

4. 线程的同步

1.线程安全问题存在的原因？

　　由于一个线程在操作共享数据过程中，未执行完毕的情况下，另外的线程参与进来，导致共享数据存在了安全问题。

2.如何来解决线程的安全问题？

　　必须让一个线程操作共享数据完毕以后，其它线程才有机会参与共享数据的操作。

3.java如何实现线程的安全：线程的同步机制

　　方式一：同步代码块

synchronized(同步监视器){
        //需要被同步的代码块（即为操作共享数据的代码）
}    

　　　　1.共享数据：多个线程共同操作的同一个数据(变量)

　　　　2.同步监视器：由一个类的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码。俗称：锁

　　　　　　要求：所有的线程必须共用同一把锁！

　　　　注：在实现的方式中，考虑同步的话，可以使用this来充当锁。但是在继承的方式中，慎用this!

　　方式二：同步方法

　　　　将操作共享数据的方法声明为synchronized。即此方法为同步方法，能够保证当其中一个线程执行此方法时，其它线程在外等待直至此线程执行完此方法。

　　　　　　>同步方法的锁：this

4.线程的同步的弊端：由于同一个时间只能有一个线程访问共享数据，效率变低了。

同步方法（非静态的）的锁为this。

同步方法（静态的）的锁为当前类本身。

小结：释放锁的操作

　　当前线程的同步方法、同步代码块执行结束

　　当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。

　　当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束

　　当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

小结：不会释放锁的操作

　　线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行

　　线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。

　　　　应尽量避免使用suspend()和resume()来控制线程

线程的死锁问题

　　死锁

　　　　不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

　　解决方法

　　　　专门的算法、原则

　　　　尽量减少同步资源的定义

5. 线程通信

wait() 与 notify() 和 notifyAll()

　　wait():一旦一个线程执行到wait()，就释放当前的锁。

　　notify()/notifyAll():唤醒wait的一个优先级最高的 或 所有的线程

Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常

经典例题：生产者/消费者问题

/**
 * 经典例题：生产者/消费者问题
 * 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），
 * 如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，
 * 如果店中有产品了再通知消费者来取走产品。
 */
class Clerk{
    int product;
    public synchronized void product(){
        if(product >= 20){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            product++;
            System.out.println(Thread.currentThread().getName() + "生产了第" + product + "个产品。");
            notifyAll();
        }
    }
    public synchronized void custome(){
        if(product <= 0){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            System.out.println(Thread.currentThread().getName() + "消费了第" + product + "个产品。");
            product--;
            notifyAll();
        }
    }
}
class Productor implements Runnable{
    Clerk clerk;
    public Productor(Clerk clerk){
        this.clerk = clerk;
    }
    public void run() {
        System.out.println("生产者开始生产");
        while(true){
            try {
                Thread.sleep((int)(Math.random()*1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.product();
        }
    }
}
class Customer implements Runnable{
    Clerk clerk;
    public Customer(Clerk clerk){
        this.clerk = clerk;
    }
    public void run() {
        System.out.println("消费者开始消费");
        while(true){
            try {
                Thread.sleep((int)(Math.random()*1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.custome();
        }
    }
}
public class ProduceConsume {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Productor p1 = new Productor(clerk);
        Productor p2 = new Productor(clerk);
        Customer c1 = new Customer(clerk);
        Thread t1= new Thread(p1);
        Thread t2 = new Thread(c1);
        Thread t3 = new Thread(p2);
        t1.start();
        t2.start();
        t3.start();
    }
}