多线程

一、理解程序、进程、线程的概念

        程序可以理解为静态的代码；
        进程可以理解为执行中的程序；

        线程可以理解为进程的进一步细分，程序的一条执行路径；

二、如何创建java程序的线程（重点）

        方式一：继承于Thread类；

class PrintNum extends Thread{
	public void run(){
		//子线程执行的代码
		for(int i = 1;i <= 100;i++){
			if(i % 2 == 0){
				System.out.println(Thread.currentThread().getName() + ":" + i);
			}
		}
	}
	public PrintNum(String name){
		super(name);
	}
}


public class TestThread {
	public static void main(String[] args) {
		PrintNum p1 = new PrintNum("线程1");
		PrintNum p2 = new PrintNum("线程2");
		p1.setPriority(Thread.MAX_PRIORITY);//10
		p2.setPriority(Thread.MIN_PRIORITY);//1
		p1.start();
		p2.start();
	}
}

        方式二：实现Runnable接口；

class SubThread implements Runnable{
	public void run(){
		//子线程执行的代码
		for(int i = 1;i <= 100;i++){
			if(i % 2 == 0){
				System.out.println(Thread.currentThread().getName() + ":" + i);
			}
		}			
	}
}
public class TestThread{
	public static void main(String[] args){
		SubThread s = new SubThread();
		Thread t1 = new Thread(s);
		Thread t2 = new Thread(s);
		
		t1.setName("线程1");
		t2.setName("线程2");
		
		t1.start();
		t2.start();
	}
}

两种方式的对比：联系：class Thread implements Runnable；比较哪个好？实现的方式较好。①解决了单继承的局限性。②如果多个线程有共享数据的话，建议使用实现方式，同时，共享数据所在的类可以作为Runnable接口的实现类。线程里的常用方法：start()、run()、currentThread()、getName() 、setName(String name)、yield()、join() 、sleep()、isAlive()、getPriority() 、setPriority(int i)、wait() 、notify()、notifyAll()；

三、线程的同步机制（重点、难点）

        前提：如果我们创建的多个线程，存在着共享数据，那么就有可能出现线程的安全问题：当其中一个线程操作共享数据时，还未操作完成，另外的线程就参与进来，导致对共享数据的操作出现问题。

           解决方式：要求一个线程操作共享数据时，只有当其完成操作完成共享数据，其它线程才有机会执行共享数据。

           方式一：同步代码块：synchronized(同步监视器){//操作共享数据的代码}注：1.同步监视器：俗称锁，任何一个类的对象都可以才充当锁。要想保证线程的安全，必须要求所有的线程共用同一把锁！        2.使用实现Runnable接口的方式创建多线程的话，同步代码块中的锁，可以考虑是this。如果使用继承Thread类的方式，慎用this!        3.共享数据：多个线程需要共同操作的变量。   明确哪部分是操作共享数据的代码。

           方式二：同步方法：将操作共享数据的方法声明为synchronized。   比如：public synchronized void show(){ //操作共享数据的代码}注：1.对于非静态的方法而言，使用同步的话，默认锁为：this。如果使用在继承的方式实现多线程的话，慎用！        2.对于静态的方法，如果使用同步，默认的锁为：当前类本身。

        总结：释放锁:wait()；            不释放锁： sleep()   yield()  suspend() (过时，可能导致死锁)；

        死锁：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁死锁是我们在使用同步时，需要避免的问题！

四、线程的通信

        如下的三个方法必须使用在同步代码块或同步方法中！

                   1、wait():当在同步中，执行到此方法，则此线程“等待”，直至其他线程执行

                   2、notify()的方法，将其唤醒，唤醒后继续其wait()后的代码

                   3、notify()/notifyAll():在同步中，执行到此方法，则唤醒其他的某一个或所有的被wait的线程。

package com.atguigu.java1;

//线程通信。如下的三个关键字使用的话，都得在同步代码块或同步方法中。
//wait():一旦一个线程执行到wait()，就释放当前的锁。
//notify()/notifyAll():唤醒wait的一个或所有的线程
//使用两个线程打印 1-100. 线程1, 线程2 交替打印

class PrintNum implements Runnable {
	int num = 1;
	Object obj = new Object();
	public void run() {
		while (true) {
			synchronized (obj) {
				obj.notify();
				if (num <= 100) {
					try {
						Thread.currentThread().sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + ":"
							+ num);
					num++;
				} else {
					break;
				}
				
				try {
					obj.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

}

public class TestCommunication {
	public static void main(String[] args) {
		PrintNum p = new PrintNum();
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(p);
		
		t1.setName("甲");
		t2.setName("乙");
		
		t1.start();
		t2.start();
	}
}

注：以上内容均为转载，如果遇到侵权请联系博主进行删除。