正文

重识JAVA 之 多线程

高亚轩
高亚轩 V管理员 /1 评论 /6494 阅读
0217
此篇文章发布距今已超过1756天，您需要注意文章的内容或图片是否可用！

推荐：  https://blog.csdn.net/evankaka/article/details/44153709


程序-线程-进程

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

  2. 进程(process)是程序的一次执行过程，或是正在运行的一个程序。进程间的切换会有较大的开销，一个进程包含1--n个线程。系统运行一个程序就是一个进程从创建、运行到消亡的过程。

                            如：运行中的QQ，运行中的MP3播放器 Ø程序是静态的，进程是动态的 .

  3. 线程(thread):进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，

线程的分类:

Java中的线程分为两类：一种是守护线程，一种是用户线程。

它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。 

守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。 Java垃圾回收就是一个典型的守护线程。 若JVM中都是守护线程，当前JVM将退出。


多线程的实现: 

 1.继承Thread类

 1)  定义子类继承Thread类。

 2)  子类中重写Thread类中的run方法。

 3)  创建Thread子类对象，即创建了线程对象。

 4)  调用线程对象start方法：启动线程，调用run方法。


2.  实现Runnable接口

1）定义子类，实现Runnable接口。

2）子类中重写Runnable接口中的run方法。

3）通过Thread类含参构造器创建线程对象。

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

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


Thread实现多线程:

Thread类的有关方法.

 void start():  启动线程，并执行对象的run()方法 .

run():  线程在被调度时执行的操作. 

String getName():  返回线程的名称. 

void setName(String name):设置该线程名称. 

static currentThread(): 返回当前线程.

static  void  yield()：线程让步 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程 若队列中没有同优先级的线程，忽                                     略此方法 .

join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止    低优先级的线程也可以获得执行.  

static  void  sleep(long millis)：(指定时间:毫秒) 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。 抛出InterruptedException异常 .

stop(): 强制线程生命期结束.

boolean  isAlive()：返回boolean，判断线程是否还活着.


线程的调度:



线程的优先级:

 线程的优先级控制 

MAX_PRIORITY（10）;   

 MIN _PRIORITY （1）; 

 NORM_PRIORITY （5）; 

涉及的方法： getPriority() ：返回线程优先值  

                       setPriority(int newPriority) ：改变线程的优先级 线程创建时继承父线程的优先级


线程的生命:

 Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态： 

新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态. 

就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件. 

运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能. 

阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态 .

死亡：线程完成了它的全部工作或线程被提前强制性地中止   .

例子:

/*
 * 创建两个个子线程，完成1-10之间自然数的输出。同样地，主线程执行同样的操作
 * 创建多线程的第一种方式：继承java.lang.Thread类
 */
//1.创建一个继承于Thread的子类
class SubThread extends Thread{
	//2.重写Thread类的run()方法.方法内实现此子线程要完成的功能
	public void run(){
		for(int i = 1;i <= 10;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 <= 10;i++){
			System.out.println(Thread.currentThread().getName() +":" + i);
		}
	}
}

运行结果:
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
Thread-0:5
Thread-0:6
Thread-0:7
Thread-0:8
Thread-0:9
Thread-0:10
main:1
Thread-1:1
Thread-1:2
Thread-1:3
Thread-1:4
Thread-1:5
Thread-1:6
Thread-1:7
Thread-1:8
main:2
Thread-1:9
Thread-1:10
main:3
main:4
main:5
main:6
main:7
main:8
main:9
main:10


设置优先级打印:

class SubThread1 extends Thread {
	public void run() {
		for (int i = 1; i <= 100; i++) {
		
			System.out.println(Thread.currentThread().getName() + ":"
					+ Thread.currentThread().getPriority() + ":" + i);
		}
	}
}

public class TestThread1 {
	public static void main(String[] args) {

		SubThread1 st1 = new SubThread1();
		st1.setName("子线程1");
		st1.setPriority(Thread.MAX_PRIORITY);
		st1.start();
		Thread.currentThread().setName("========主线程");
		for (int i = 1; i <= 100; i++) {
			System.out.println(Thread.currentThread().getName() + ":"
					+ Thread.currentThread().getPriority() + ":" + i);
		
		}
		System.out.println(st1.isAlive());
	}
}

会发现子线程会先完成打印;

Runnable实现多线程:

//模拟火车站售票程序，开启三个窗口售票。

class Ticket implements Runnable{
    private  int tick = 100;
    public void run(){
    while(true){
        if(tick>0){
        try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO 自动生成的 catch 块
					e.printStackTrace();
				}
System.out.println(Thread.currentThread().getName()+“售出车票，tick号为："+ tick--);
         }
       else
            break;
     }
  }
}





class  TicketDemo{
    public static void main(String[] args) {

    Ticket t = new Ticket();

    Thread t1 = new Thread(t);
    Thread t2 = new Thread(t);
    Thread t3 = new Thread(t);
     t1.setName("t1窗口");
     t2.setName("t2窗口");
     t3.setName("t3窗口");
     t1.start();
     t2.start();
     t3.start();
    }
}



  此程序存在线程的安全问题：打印车票时，会出现重票、错票

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

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

    

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

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

  

 线程之间的同步:


    方式一：同步代码块

   synchronized(同步监视器){

  //需要被同步的代码块（即为操作共享数据的代码）

    }

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

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

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

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

 

  方式二：同步方法

 将操作共享数据的方法声明为synchronized。即此方法为同步方法，能够保证当其中一个线程执行

 此方法时，其它线程在外等待直至此线程执行完此方法。

  >同步方法的锁：this

  

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


互斥锁:

 在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。 

  •     每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。 

  •     关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问

  •     同步的局限性：导致程序的执行效率要降低 

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

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

释放锁的操作:

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

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

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

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

 

不会释放锁的操作:

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

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

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

 

用同步代码块来实现线程同步:

class Window3 extends Thread {
	static int ticket = 100;
	static Object obj = new Object();

	public void run() {
		while (true) {
			// synchronized (this) {//在本问题中，this表示：w1,w2,w3
			synchronized (obj) {
				// show();
				if (ticket > 0) {
					try {
						Thread.currentThread().sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "售票，票号为：" + ticket--);
				}
			}
		}
	}

	public synchronized void show() {// this充当的锁
		if (ticket > 0) {
			try {
				Thread.currentThread().sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "售票，票号为："
					+ ticket--);
		}
	}
}

public class TestWindow3 {
	public static void main(String[] args) {
		Window3 w1 = new Window3();
		Window3 w2 = new Window3();
		Window3 w3 = new Window3();

		w1.setName("窗口1");
		w2.setName("窗口2");
		w3.setName("窗口3");

		w1.start();
		w2.start();
		w3.start();

	}

}


用同步方法来实现;

class Window4 implements Runnable {
	int ticket = 100;// 共享数据

	public void run() {
		while (true) {
			show();
		}
	}

	public synchronized void show() {
		
		if (ticket > 0) {
			try {
				Thread.currentThread().sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "售票，票号为："
					+ ticket--);
		}

	}
}

public class TestWindow4 {
	public static void main(String[] args) {
		Window4 w = new Window4();
		Thread t1 = new Thread(w);
		Thread t2 = new Thread(w);
		Thread t3 = new Thread(w);

		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");

		t1.start();
		t2.start();
		t3.start();
	}
}




线程死锁的问题:

 死锁 

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

解决方法 

专门的算法、原则 Ø尽量减少同步资源的定义.

class A {
	public synchronized void foo(B b) {//锁：A的对象a
		try {
			Thread.currentThread().sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		b.last();
	}

	public synchronized void last() {//锁：A的对象a
	}
}

class B {
	public synchronized void bar(A a) {//锁：B的对象 b
		try {
			Thread.currentThread().sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		a.last();
	}

	public synchronized void last() {//锁：B的对象 b
		
	}
}

public class DeadLock implements Runnable {
	A a = new A();
	B b = new B();

	public void init() {
		a.foo(b);
	}

	public void run() {
		b.bar(a);
	}

	public static void main(String[] args) {
		DeadLock dl = new DeadLock();
		new Thread(dl).start();
		dl.init();
	}
}


线程的通信:

 wait() 与 notify() 和 notifyAll() 

  • wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问 

  • notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待 

  • notifyAll ()：唤醒正在排队等待资源的所有线程结束等待. lJava.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常


wait方法:

  •  在当前线程中调用方法：  对象名.wait() l使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。 

  • 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁） 

  • 调用此方法后，当前线程将释放对象监控权  ，然后进入等待 

  • 在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。


notify()/notifyAll():

  •  在当前线程中调用方法：  对象名.notify() 

  •  功能：唤醒等待该对象监控权的一个线程。 

  • 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）


例子:

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();
	}
}



转载请注明出处
-- 展开阅读全文 --