Java学习笔记五（多线程）

1.介绍

线程可以使程序具有两条和两条以上的可运行的路径。尤其对多核CPU特别的重要。

2.创建线程

1.继承Thread类

一个类直接的继承Thread类的话，此类就具有了线程的能力，接下来仅仅须要重写继承的run()就可以。

<span style="font-size:18px;">package com.Thread;

//定义实现Runnable接口的类
class MyThread11 extends Thread
{
	//实现run方法。指定线程运行的任务
	public void run()
	{

		System.out.println("启动一个线程！");
	}
}
//主类
public class Sample16_2
{
	public static void main(String[] args)
	{
		//继承Thread的类创建线程对象

		Thread t=new MyThread11();
		//启动线程
		t.start();
		System.out.println("启用线程了");
	}
}
</span>

2.实现Runnable接口

java採用的单继承，假设採用继承Thread类的话，会有非常多限制，因此常常採用的是继承Runnable接口来实现线程的创建。

<span style="font-size:18px;">package com.Thread;

//定义实现Runnable接口的类
class MyRunnable implements Runnable
{
	//实现run方法。指定线程运行的任务
	public void run()
	{

		System.out.println("恭喜你。线程被启动了，"
		               +"运行了run方法中的代码！

。。");
	}
}
//主类
public class Sample16_1
{
	public static void main(String[] args)
	{
		//创建实现Runnable接口的类的对象
		MyRunnable mr=new MyRunnable();
		//创建Thread对象，将第一步创建对象的引用作为构造器參数
		//传递，指定线程要运行的任务
		Thread t=new Thread(mr);
		//启动线程
		t.start();
		System.out.println("启用线程了");
	}
}
</span>

3.线程的同步

1.同步方法

同步方法是指使用synchronizedkeyword修饰的方法，进入同步方法运行的线程将获得同步方法所属对象的锁，一旦锁住。仅仅有该线程运行完，其它线程才干运行。因此保证了方法同步的安全性。

<span style="font-size:18px;">package com.Thread;
//资源类
class Resource
{
	synchronized void function1(Thread currThread)
	{
		System.out.println(currThread.getName()+
		"线程运行function1方法。！

！");
		try
		{
			Thread.sleep(1000);
			System.out.println(currThread.getName()
			+"线程睡醒了！

！

！

");
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
	}
	synchronized void function2(Thread currThread)
	{
		System.out.println(currThread.getName()+
		"线程运行function2方法！！

！");
	}
}
//自己定义线程类
class MyThread00 extends Thread
{
	//资源对象的引用
	Resource rs;
	//构造器
	public MyThread00(String tName,Resource rs)
	{
		this.setName(tName);
		this.rs=rs;
	}
	public void run()
	{
		if(this.getName().equals("Thread1"))
		{//假设线程名称是Thread1訪问资源的function1方法
		     rs.function1(this);
		}
		else
		{//假设线程名称不是Thread1訪问资源的function2方法
			System.out.println("Thread2启动。等待进入同步方法function2。。！");
			rs.function2(this);
		}
	}
}
//主类
public class Sample16_8
{
	public static void main(String args[])
	{
       Resource rs=new Resource();
       MyThread00 t1=new MyThread00("Thread1",rs);
       MyThread00 t2=new MyThread00("Thread2",rs);
       t1.start();
		 try
		 {
			Thread.sleep(10);
	 	 }
		 catch(Exception e)
		 {
			e.printStackTrace();
		 }
       t2.start();
	}
}
</span>

注意：一个对象能够有同步和非同步方法，仅仅有进入同步方法运行才须要获得锁。每一个对象仅仅有一把锁；若一个对象有多个同步的方法，当某线程訪问当中之中的一个的时候。其它线程不能訪问该对象重点额不论什么同步方法。若线程获得锁后进入睡眠或让步，则将带着锁一块睡眠或让步。

2.同步语句块

使用同步语句块能够提高程序的并发性，能够精确的确定同步的区域。

<span style="font-size:18px;">package com.Thread;

//自己定义的线程类
class MyThread33 extends Thread
{
	//该引用为资源对象
	private Object resource;
	//无參构造器
	public MyThread33()
	{}
	//有參构造器
	public MyThread33(Object resource,String name)
	{
		//对线程进行初始化
		this.resource=resource;
		this.setName(name);
	}
	public void run()
	{
		//同步语句块
		synchronized(resource)
		{
          System.out.println(this.getName()
          +"线程訪问了资源！

！。");
          System.out.println(this.getName()
          +"线程带着锁睡觉去了！

！。");
          try
          {
          	Thread.sleep(1000);
          }
          catch(Exception e)
          {
          	e.printStackTrace();
          }
          System.out.println(this.getName()
          +"线程带着锁睡醒后释放了锁！！！

");
		}
	}
}
//主类
public class Sample16_10
{
	public static void main(String[] args)
	{
		//创建资源对象
		Object resource=new Object();
		//创建2个线程
		MyThread33 mt1=new MyThread33(resource,"MT1");
		MyThread33 mt2=new MyThread33(resource,"MT2");
		//启动这2个线程
		mt1.start();
		mt2.start();
	}
}
</span>

注意：当中synchronized(XXX)，XXX代表的是资源对象的引用。

4.线程的其它设置

1.线程的优先级

java中线程的优先级用1到10之间的整数表示，数值越大优先级越高。获得訪问CPU的机会越大。一般採用setPriority方法来设置。

<span style="font-size:18px;">package com.Thread;

//定义继承Thread的类
class MyThread1 extends Thread {
	// 重写run方法，指定该线程运行的代码
	public void run() {
		for (int i = 0; i <= 49; i++) {
			System.out.print("<Min" + i + "> ");
		}
	}
}

// 定义另外一个继承Thread的类
class MyThread2 extends Thread {
	// 重写run方法，指定该线程运行的代码
	public void run() {
		for (int i = 0; i <= 49; i++) {
			System.out.print("[Max" + i + "] ");
		}
	}
}

// 主类
public class Sample16_4 {
	public static void main(String[] args) {
		// 创建两个线程对象
		MyThread1 t1 = new MyThread1();
		MyThread2 t2 = new MyThread2();
		// 设置两个线程的优先级
		t1.setPriority(Thread.MIN_PRIORITY);
		t2.setPriority(Thread.MAX_PRIORITY);
		// 启动两个线程
		t1.start();
		t2.start();

	}
}
</span>

2.线程的让步

在实际开发中有时候也须要让某线程让出CPU。使其它线程得意运行。这时候能够採用让步的操作。

一般调用yield方法。

<span style="font-size:18px;">package com.Thread;

//定义Runnable的实现类
class MyRunnable1 implements Runnable
{
	//声明标识线程的两个字符串
	private String flagl;
	private String flagr;
	//MyRunnable的构造器
	public MyRunnable1(String flagl,String flagr)
	{
		//初始化标识字符串
		this.flagl=flagl;
		this.flagr=flagr;
	}
	//重写run方法，指定该线程运行的代码
	public void run()
	{
		for(int i=0;i<30;i++)
		{
			System.out.print(flagl+i+flagr);
			//调用yield方法使当前正在运行的线程让步
			Thread.yield();
		}
	}
}
//主类
public class Sample16_5
{
	public static void main(String[] args)
	{
		//创建两个实现Runnable接口的类的对象
		MyRunnable1 mr1=new MyRunnable1("[","] ");
		MyRunnable1 mr2=new MyRunnable1("<","> ");
		//创建两个线程Thread对象，并指定运行的target
		Thread t1=new Thread(mr1);
		Thread t2=new Thread(mr2);
		//启动线程t1、t2
		t1.start();
		t2.start();
	}
}
</span>

5.总结

本篇文章简单的总结了线程中的一些概念，可是这些概念是以后开发高级线程必备的知识，须要多理解。