JavaSE 注解和多线程，JavaSE注解多线程

JavaSE 注解和多线程，JavaSE注解多线程

注解

Java代码里的特殊标记。注解可以在编译、类加载、运行时被读取

注释不会被程序所读取（class文件中不会有注释但可以有注解，编译器会自动忽略掉注释）

分类：

1.    内建注解：定义好的标准注解类型 @Override, @SuppressWarnings

2.    元注解：修饰其他注解的定义 @Target、@Retention

3.    自定义注解，是一种接口，使用关键字@interface定义

自定义注解要与元注解配合使用

@Target 和 @Retention

@Target

指定被器修饰的注解能用于修饰哪些程序元素

成员变量value为ElementType枚举类型，取值如下：

1.    ElementType.CONSTRUCTOR：用于描述构造器

2.    ElementType.FIELD：用于描述域（字段，即成员变量）

3.    ElementType.LOCAL_VARIABLE：用于描述局部变量

4.    ElementType.METHOD：用于描述方法

5.    ElementType.PACKAGE：用于描述包

6.    ElementType.PARAMETER：用于描述方法的参数

7.    ElementType.TYPE：用于描述类、接口（包括注解类型）、枚举和注解

@Retention

指定该注解可以使用反射读取

成员变量value是一个RetentionPolicy枚举类型，取值范围：

1.    RetentionPolicy.SOURCE：在源文件中有效（在源文件中保留注解）

2.    RetentionPolicy.CLASS：在class文件中有效（在class文件中保留）

3.    RetentionPolicy.RUNTIME：在运行时有效（运行时保留）

多线程

Java是一门多线程语言

进程：每一个软件运行就会在OS中产生一个进程，进程也是一个线程，也叫主线程

程序运行过程中，也可以产生子线程

一个程序可以同时进行多项任务

真正在处理机上运行的是线程，线程是执行运算的最小单位


创建线程的方式

1.    继承java.lang.Thread类

2.    实现java.lang.Runnable接口

线程的四大状态

新生状态 实例化线程对象后

可运行状态 调用start方法后

阻塞状态 线程被挂起时

死亡状态 线程结束


线程的四大方法

Tread.sleep(ms);  //运行到这一句时，线程暂停ms毫秒，把对CPU的执行权交出 
Tread.setPriority() //设置线程的优先级，可以更高几率的获取到CPU的执行权
Tread.join();      //阻塞，可以阻止另一个线程的运行
yield();       //当前线程转入暂停状态 ，交出当前CPU执行权，但可以立刻获得执行权

线程同步

//多个线程共享同一个数据
//解决方法：加锁
//同步代码块，关键字后的小括号表示锁，可以是程序中的任意对象
synchronized (object) {}  // object即为锁	
//同步方法
public synchronized void run() {}	

线程同步案例：夫妻取钱 取款类

package com.etc.homework.thread.drawMoney;

public class Account {

	private double deposit;
	
	public Account(double deposit) {
		// TODO Auto-generated constructor stub
		this.deposit = deposit;
	}
	
	/**
	 * 取款
	 * @param name : 取款人姓名
	 * @param money ： 取款额度
	 * @return ：返回true表示取款成功，false表示余额不足，取款失败
	 */
	public synchronized boolean drawMoney(String name, double money) {
		System.out.println(name + " 开始取款");
		//若余额大于或等于取款，则取款成功，否则失败
		if(deposit >= money) {
			deposit -= money;
			System.out.println(name + " 完成取款, 余额为" + deposit);
			return true;
		} else {
			System.out.println("余额不足以支付 " + name + " 的取款，余额为"+ deposit);
			return false;
		}
	}
	
}

银行卡类

package com.etc.homework.thread.drawMoney;

public class BankCard implements Runnable {
	
	private Account account;
	
	private double drawMoney;
	
	public BankCard(Account account, double drawMoney) {
		// TODO Auto-generated constructor stub
		this.account = account;
		this.drawMoney = drawMoney;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		//获得取款人姓名
		String name = Thread.currentThread().getName();
		//若可以取款，则没隔0.1秒请求一次取款操作
		while(true) {
			boolean flag = account.drawMoney(name, drawMoney);
			try {
				//设置取款请求间隔
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//取款失败，表示余额不足，结束取款
			if(!flag)break;
		}
		
	}
	
}

存折类

package com.etc.homework.thread.drawMoney;

public class Passbook implements Runnable  {
	
	private Account account;
	
	private double drawMoney;
	
	public Passbook(Account account, double drawMoney) {
		// TODO Auto-generated constructor stub
		this.account = account;
		this.drawMoney = drawMoney;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		//获得取款人姓名
		String name = Thread.currentThread().getName();
		//若可以取款，则没隔0.1秒请求一次取款操作
		while(true) {
			boolean flag = account.drawMoney(name, drawMoney);
			try {
				//设置取款请求间隔
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//取款失败，表示余额不足，结束取款
			if(!flag)break;
		}
		
	}
	
}

测试类

package com.etc.homework.thread.drawMoney;

public class ThreadTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Account account = new Account(10000);
		
		BankCard bankCard = new BankCard(account, 169.5);
		Passbook passbook = new Passbook(account, 564.5);
		
		Thread thread_1 = new Thread(bankCard, "张三");
		Thread thread_2 = new Thread(passbook, "张三的妻子");
		
		thread_1.start();
		thread_2.start();
		
	}

}

线程通信

//这些方法只能在同步方法或同步代码块中使用
wait()          //挂起线程，并释放锁
notify()        //随机释放一个因wait()方法而挂起的线程
notifyAll()     //释放全部因wait()方法挂起的线程