java多线程技术

最新推荐文章于 2024-06-19 21:11:55 发布

_csdnw

最新推荐文章于 2024-06-19 21:11:55 发布

阅读量440

点赞数

分类专栏： java多线程技术文章标签： java多线程技术

本文链接：https://blog.csdn.net/csdnwangzhan/article/details/42127435

版权

java多线程技术专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1、进程和线程

进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以有多个线程。

多线程:在同一个进程中同时运行的多个任务;

2、创建线程方式

1、继承Thread类

子类覆写父类中的run方法，将线程运行的代码存放在run中。

建立子类对象的同时线程也被创建。

通过调用start方法开启线程。

如：

class MyThread extends Thread{
	public void run(){
		System.out.println(name+"启动！");
	}
}

2、实现Runnable接口

子类覆盖接口中的run方法。

通过Thread类创建线程，并将实现了Runnable接口的子类对象作为参数传递给Thread类的构造函数。

Thread类对象调用start方法开启线程。

可使用匿名内部类来写

如：

class YourThread implements Runnable{
	public void run() {
		for (int i = 0; i < 3; i++) {
			System.out.println(Thread.currentThread().getName()+"第"+i+"次启动！");
		}
	}

3、两种进程创建方式比较

建议用第二种方式，因为避免了单继承的局限性。

4、线程的生命周期

Thread类内部有个public的枚举Thread.State，里边将线程的状态分为：
     NEW-------新建状态，至今尚未启动的线程处于这种状态。
     RUNNABLE-------运行状态，正在 Java 虚拟机中执行的线程处于这种状态。
     BLOCKED-------阻塞状态，受阻塞并等待某个监视器锁的线程处于这种状态。
     WAITING-------冻结状态，无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
     TIMED_WAITING-------等待状态，等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。
     TERMINATED-------已退出的线程处于这种状态。

5、控制线程

join方法：调用join方法的线程对象强制运行，该线程强制运行期间，其他线程无法运行，必须等到该线程结束后其他线程才可以运行。

有人也把这种方式成为联合线程

join方法的重载方法:

join(long millis):

join(long millis,int nanos):

Daemon

后台线程：处于后台运行，任务是为其他线程提供服务。也称为“守护线程”或“精灵线程”。JVM的垃圾回收就是典型的后台线程。

特点：若所有的前台线程都死亡，后台线程自动死亡。

设置后台线程：Thread对象setDaemon(true);

setDaemon(true)必须在start()调用前。否则出现IllegalThreadStateException异常；

前台线程创建的线程默认是前台线程;

判断是否是后台线程：使用Thread对象的isDaemon()方法；

并且当且仅当创建线程是后台线程时，新线程才是后台线程。

sleep

线程休眠:

让执行的线程暂停一段时间，进入阻塞状态。

sleep(long milllis) throws InterruptedException：毫秒

sleep(long millis,int nanos)

throws InterruptedException:毫秒，纳秒

调用sleep()后，在指定时间段之内，该线程不会获得执行的机会。

控制线程之优先级

每个线程都有优先级，优先级的高低只和线程获得执行机会的次数多少有关。

并非线程优先级越高的就一定先执行，哪个线程的先运行取决于CPU的调度;

默认情况下main线程具有普通的优先级，而它创建的线程也具有普通优先级。

Thread对象的setPriority(int x)和getPriority()来设置和获得优先级。

MAX_PRIORITY : 值是10

MIN_PRIORITY : 值是1

NORM_PRIORITY : 值是5(主方法默认优先级)

yield

线程礼让:

暂停当前正在执行的线程对象，并执行其他线程；

Thread的静态方法，可以是当前线程暂停，但是不会阻塞该线程，而是进入就绪状态。所以完全有可能：某个线程调用了yield()之后，线程调度器又把他调度出来重新执行。

6、多线程安全问题

导致安全问题的出现的原因：

多个线程访问出现延迟。

线程随机性。

7、多线程安全问题的解决方法

三种方法：

同步代码块：

synchronized(obj)

{

//obj表示同步监视器,是同一个同步对象

/**.....

TODO SOMETHING

}

同步方法

格式：

在方法上加上synchronized修饰符即可。（一般不直接在run方法上加！）

synchronized 返回值类型方法名(参数列表)

{

/**.....

TODO SOMETHING

}

同步方法的同步监听器其实的是 this

静态方法的同步

同步方法

同步代码块

static不能和 this连用

静态方法的默认同步锁是当前方法所在类的.class对象

同步锁

jkd1.5后的另一种同步机制：

通过显示定义同步锁对象来实现同步，这种机制，同步锁应该使用Lock对象充当。

在实现线程安全控制中，通常使用ReentrantLock(可重入锁)。使用该对象可以显示地加锁和

解锁。

具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

8、线程通信

有一个数据存储空间,划分为两部分,一部分用于存储人的姓名,另一部分用于存储人的性别;

我们的应用包含两个线程,一个线程不停向数据存储空间添加数据(生产者),另一个线程从数据空间取出数据(消费者);

因为线程的不确定性，存在于以下两种情况：

若生产者线程刚向存储空间添加了人的姓名还没添加人的性别，CPU就切换到了消费者线程，消费者线程把姓名和上一个人的性别联系到一起；

生产者放了若干数据，消费者才开始取数据，或者是消费者取完一个数据，还没等到生产者放入新的数据，又重复的取出已取过的数据；

生产者和消费者

wait():让当前线程放弃监视器进入等待，直到其他线程调用同一个监视器并调用notify()或notifyAll()为止。

notify():唤醒在同一对象监听器中调用wait方法的第一个线程。

notifyAll():唤醒在同一对象监听器中调用wait方法的所有线程。

这三个方法只能让同步监听器调用:

在同步方法中: 谁调用

在同步代码块中: 谁调用

wait()、notify()、notifyAll()，这三个方法属于Object 不属于 Thread，这三个方法必须由同步监视对象来调用，两种情况：

1.synchronized修饰的方法，因为该类的默认实例(this)就是同步监视器，所以可以在同步方法中调用这三个方法;

2.synchronized修饰的同步代码块，同步监视器是括号里的对象，所以必须使用该对象调用这三个方法;

可要是我们使用的是Lock对象来保证同步的,系统中不存在隐式的同步监视器对象,那么就不能使用者三个方法了,那该咋办呢?

此时,Lock代替了同步方法或同步代码块,Condition代替了同步监视器的功能;

Condition对象通过Lock对象的newCondition()方法创建;

里面方法包括:

await(): 等价于同步监听器的wait()方法;

signal(): 等价于同步监听器的notify()方法;

signalAll(): 等价于同步监听器的notifyAll()方法;

class Person{
	private String name;
	private String sex;
	private Boolean isimpty = Boolean.TRUE;//内存区为空！
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	
	public void set(String name,String sex){
		synchronized (this) {
			while(!isimpty.equals(Boolean.TRUE)){//不为空的话等待消费者消费！
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			this.name = name;//为空的话生产者创造！
			this.sex = sex;
			isimpty = Boolean.FALSE;//创造结束后修改属性！
			this.notifyAll();
		}
	}
	
	public void get(){
		synchronized (this) {
			while(!isimpty.equals(Boolean.FALSE)){
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("姓名"+getName()+ ",  "+"性别"+getSex());
			isimpty = Boolean.TRUE;
			this.notifyAll();
		}
	}
}

class Producer implements Runnable{
	private Person p;
	
	public Producer(Person p) {
		super();
		this.p = p;
	}

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			if( i % 2 == 0){
				p.set("刘昭", "男");
			}else{
				p.set("章泽天", "女");
			}
		}
	}
}

class Consumer implements Runnable{
	private Person p;
	
	public Consumer(Person p) {
		super();
		this.p = p;
	}

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			p.get();
		}
	}
}

public class Demo9 {
	public static void main(String[] args) {
		Person p = new Person();
		
		new Thread(new Producer(p)).start();
		new Thread(new Consumer(p)).start();
	}
}