黑马程序员——多线程

night123789

于 2014-12-31 14:56:18 发布

阅读量265

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/night123789/article/details/42295025

版权

java基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

一，概述

1，进程

是一个正在执行的程序。

每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

2，线程

就是进程中的一个独立的控制单元。线程在控制着进程的执行。只要进程中有一个线程在执行，进程就不会结束。

一个进程中至少有一个线程。

3，多线程存在的意义

多线程的出现能让程序产生同时运行效果。可以提高程序执行效率。

二，创建线程的方式

方式一：继承

就是通过继承Thread类，然后复写其run方法的方式来创建线程。

步骤：

a，定义类继承Thread。

b，复写Thread中的run方法。

目的：将自定义代码存储在run方法中，让线程运行。

c，创建定义类的实例对象。相当于创建一个线程。

d，用该对象调用线程的start方法。该方法的作用是：启动线程，调用run方法。

注：如果对象直接调用run方法，等同于只有一个线程在执行，自定义的线程并没有启动。

示例：

public class thread_text {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		new Thread(new lineone()).start();//创建线程并启动
		new Thread(new linetwo()).start();
		
	}
	public synchronized void print(Object obj){
		System.out.println(obj);
	}
	
}
class lineone implements Runnable
{
	public void run()//覆盖run方法，方法内为线程要执行的代码
	{
		long begin=System.currentTimeMillis();
		for(int k=0;k<100;k++){
			System.out.println("*********"+k);
		}
		long end=System.currentTimeMillis();
		System.out.println(end-begin);
	}
}
class linetwo implements Runnable{
	public void run(){
		long begin=System.currentTimeMillis();
		for(int k=0;k<100;k++){
			System.out.println("---------"+k);
		}
		long end=System.currentTimeMillis();
		System.out.println(end-begin);
	}
}

方式二：实现

实现Runnable接口，并复习其中run方法的方式。

步骤：

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

b，覆盖Runnable接口中的run方法。目的也是为了将线程要运行的代码存放在该run方法中。

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

d，将Runnable接口的子类对象作为实参传递给Thread类的构造方法。

示例：

public class threaddemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		new Thread(new newline()).start();//Runnable接口子类对象作为参数传递给Thread类构造函数并调用start方法启动线程。
	}

}
class newline implements Runnable//实现Runnable接口  
{  
          
    public void run()//覆盖接口run方法   放入要被线程执行的代码。  
    {               
        int x=0;  
        while(x<10)  
        {  
            System.out.println("我是新线程");  
              x++;
        }  
          
    }  
  
  
}

三，两种方式的区别与线程的状态

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

实现Runnable：线程代码存放在接口子类run方法中。

几种状态：

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

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

临时状态（阻塞）：有执行资格，但是没有执行权。

冻结状态：遇到sleep（time）方法和wait（）方法时，失去执行资格和执行权，sleep方法时间到或者调用notify（）方法时，获得执行资格，变为临时状态。

消忙状态：stop（）方法，或者run方法结束。

四，线程的安全

1，多个线程同时访问共享数据时，会出现安全问题

2，解决办法——线程同步

对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。

有两种解决方式，一种是同步代码块，还有就是同步函数。都是利用关键字synchronized来实现。

a，同步代码块

用法：

synchronized（对象）

{需要被同步的代码}

b，同步函数

格式：

在函数上加上synchronized修饰符即可。

同步的前提

a，必须要有两个或者两个以上的线程。

b，必须是多个线程使用同一个锁。

3，同步的利弊

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

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

4，线程的锁

同步函数使用的锁是this。

静态函数所使用的锁是该方法所在类的字节码文件对象。类名.class

五，死锁

当同步中嵌套同步时，就有可能出现死锁现象。

示例：

public class threaddemo3//死锁练习。
{

		public static void main(String[] args) {
			
			new Thread(new Test(true)).start();
			new Thread(new Test(false)).start();
			
		}
	}


	class Test implements Runnable
	{
		private boolean flag;
		Test(boolean flag)
		{
			this.flag=flag;
		}

		public void run()
		{
			if(flag)
			{
				while(true)
				{
					synchronized(ownlock.locka)
					{   System.out.println("if heima a");
						synchronized(ownlock.lockb)
						{
							System.out.println("if heima b");
						}
					}
				}
				
				
			}
			else
			{
				while(true)
				{
					synchronized(ownlock.lockb)
					{   System.out.println("else heima b");
						synchronized(ownlock.locka)
						{
							System.out.println("else heima a");
						}
					}
				}
				
			}
			
		}
		
	}

	class ownlock// 此类用于提供锁 。	
	{
		static Object locka = new Object();
		static Object lockb = new Object();
	}

六，线程间通信

就是多个线程在操作同一个资源，但是操作的动作不同。

示例：

public class thread_text2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		resource a=new resource();
		new Thread(new threadset(a)).start();//启动线程
		new Thread(new threadget(a)).start();
	}

}
class threadget implements Runnable//获取资源线程
{	
	resource r=null;
	threadget(resource b)//自定义构造方法，接受资源对象
	{
	this.r=b;
	}
	public void run(){
		while(true){
		r.getOutput();
		}
	}
}
class threadset implements Runnable//存储资源线程
{	
	resource r=null;
	
	threadset(resource b){
		this.r=b;
	}
	
	
	public void run(){
		while(true){
	r.setInPut("异界的旅行者","man",22);
		}
	}
	
}


class resource //资源
{
	private String name;
	private String sex;
	private int age;
	boolean f=false;
	public String toString()//重写toString方法
	{
		return ("name:"+name+"	sex:"+sex+"		age:"+Integer.toString(age));
	}
	public synchronized void setInPut(String str,String sex,int age)
	{
		
		if(f){
			try{wait();}catch(Exception e){}
		}
		
		this.name=str;
		this.sex=sex;
		this.age=age;
		f=true;
		System.out.println("存"+toString());
		notify();//唤醒
	}
	public synchronized void getOutput()
	{
		if(!f){
			try{wait();}catch(Exception e){}
		}
		System.out.println("取"+toString());
		f=false;
		notify();
	}
}

JDK1.5中提供了多线程升级解决方案。

将同步synchronized替换成显示的Lock操作。将Object中wait，notify，notifyAll，替换成了Condition对象。该Condition对象可以通过Lock锁进行获取，并支持多个相关的Condition对象。

Lock:替代了Synchronized

lock();

unlock();

newCondition();

Condition：替代了Object wait notify notifyAll

await();

signal();

signalAll();

night123789

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员——多线程

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 一，概述1，进程是一个正在执行的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。2，线程就是进程中的一个独立的控制单元。线程在控制着进程的执
复制链接

扫一扫