Java线程篇---两种构建线程的方法

Java线程篇---两种构建线程的方法 基础知识

1. 线程
   线程是 *** 作系统能够进行运算调度的最小单位，被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务
2. 线程锁
   锁定一个公共的变量在一个线程中，其它未取得的线程处于等待中，一直等到变量被线程锁释放，避免多个线程同时使用一个变量造成数据错误
3. 多线程存在的机制
   真正的同步执行几个线程是不存在的，由于CPU的处理速度极快，所以每个一定的时间处理一个线程的一部分，在人看起来就像是并行，而线程与线程之间是通过竞争来实现执行的，可以通过设置优先级来控制线程得到执行的机会

一、继承Thread来创建线程类

public class MyThread extends Thread{//继承Thread类
 	//重写run()方法
 	public void run() {
		for(int i = 0; i < 100; i++) {
 			if(interrupted()) {
 				break;//手动设置终止线程的操作
 			}
 			System.out.println("线程名" + getName() + ": " + i);
 		}
 		System.out.println("线程操作方法");
 	}
 	//测试
 	public static void main(String[] args) {
 		MyThread thread = new MyThread();
 		
 		thread.setName("线程");//修改线程名
 		System.out.println(thread.getName());//获得线程名
 		
 		System.out.println(thread.getPriority());//获得线程优先级
 		System.out.println(Thread.MAX_PRIORITY);//最大优先级
 		System.out.println(Thread.MIN_PRIORITY);//最小优先级
 		System.out.println(Thread.NORM_PRIORITY);//正常优先级
 		thread.setPriority(5);//设置优先级
 		
 		thread.start();//开启线程
 		
 		ThreadGroup thgroup = thread.getThreadGroup();//得到该线程的线程组，线程组的作用是可以批量操作线程
 		Thread th = new Thread(thgroup, "线程");//创建特定线程组的线程
 		
 		thread.setDaemon(true);//设置thread为守护线程
 		
 		thread.interrupt();//终止线程,需要在run()方法里进行相应处理，否则不会终止线程
		
 		try {
 			thread.join();//将线程加入到主线程中，然后先将该线程处理结束后，在处理主线程
 		} catch (InterruptedException e) {
 			e.printStackTrace();
 		}
 		
 		Thread mainThread = Thread.currentThread();//获得当前程序的线程
		
 		try {
 			Thread.sleep(1000);//设置当前线程休眠1秒
 		} catch (InterruptedException e) {
 			e.printStackTrace();
 		}
 	}
 }

1. 优点：创建线程对象简单
2. 缺点：创建线程间的数据共享只能通过静态变量来实现

二、实现Runnable接口来创建线程类

class MyRunnable implements Runnable{

	public void run() {
		for(int i = 0; i < 100; i++) {
			 System.out.println("线程名" + Thread.currentThread().getName() + ": " + i);
		}
	}

	public static void main(String[] args) {
		MyRunnable myRunnable = new MyRunnable();
		
		Thread thread = new Thread(myRunnable,"线程");//创建线程
		thread.start();//运行线程，其他操作等同于上面操作，此处省略
	}
}

1. 优点：实现的Runnable接口的类中定义的变量可以被所有线程共享
2. 缺点：创建线程得通过Thread()来实现

三、三种解决线程安全的方法

1. 第一种方法 —>同步锁synchronized (Object lock)

class MyRunnable implements Runnable{
	private int ticketNum = 100;
	private Object lock = new Object();//线程共有的同步锁对象
	//第一种方法
	public void run() {
		while(true) {
			synchronized (lock) {//同步锁，必须给定一个所有线程共有的变量对象
				if(ticketNum > 0) {
					System.out.println(Thread.currentThread().getName() + "卖出第" + ticketNum + "张票");
					ticketNum--;
				}
				else {
					break;
				}
			}
			
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

2. 第二种方法 —>同步方法

class MyRunnable implements Runnable{
	public void run() {
		while(ticketNum > 0) {
			saleTicket();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	private synchronized void saleTicket() {//在函数返回值前加入synchronized构成同步方法
		if(ticketNum > 0) {
			System.out.println(Thread.currentThread().getName() + "卖出第" + ticketNum + "张票");
			ticketNum--;
		}
	}
}

3. 第三种方法 —>ReentrantLock锁

class MyRunnable implements Runnable{
	private ReentrantLock lock1 = new ReentrantLock();//线程共有的锁对象
	public void run() {
		while(true) {
			lock1.lock();//上锁
			if(ticketNum > 0) {
				System.out.println(Thread.currentThread().getName() + "卖出第" + ticketNum + "张票");
				ticketNum--;
			}
			else {
				break;
			}
			lock1.unlock();//解锁
			
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

四、定时器的使用------重写TimerTask中的run()方法

class MyTimerTask extends TimerTask{

	public void run() {
		System.out.println("定时器");
	}
	
	public static void main(String[] args) {
		Timer time = new Timer();
		
		time.schedule(new MyTimerTask(), 2000,500);//延迟2s启动计时器，然后以每0.5s启动一次
		time.cancel();//关闭计时器
	}
}