java基础-线程

创建启动线程的方式一（继承Thread类）

1、自定义一个类继承Thread类;
2、覆写run方法：其中为新线程要实现的功能；
3、创建自定义类的对象 t ;
4、启动新线程： t.start();

public class PlayGameThread extends Thread{
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("玩游戏");
		}
	}
}

public class MusicThread extends Thread{
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("播放音乐");
		}
	}
}

public class Test {
	public static void main(String[] args) {
		PlayGameThread pgt = new PlayGameThread();
		MusicThread mt = new MusicThread();
		
		//启动线程
		pgt.start();
		mt.start();
	}
}

创建启动线程的方式二（实现Runnable接口）

1、自定义一个类实现Runnable接口
2、覆写run方法 ： 其中为新线程要实现的功能；
3、创建一个自定义类的对象 t
4、以t为参数来构造一个Thread对象 tt;
5、tt.start();//启动一个线程

public class TicketThread implements Runnable{
	private int num = 50;
	
	public void run() {
		// 最终的代码
		while(num>0){
			System.out.println("您的票号是："+num);
			num--;
		}
	}
}

public class Test {
	public static void main(String[] args) {
		/*
		 * 只需要创建一个TicketThread的对象   tt
		 * 以tt为参数来创建3个Thread对象
		 */
		TicketThread tt = new TicketThread();
		
		Thread t1 = new Thread(tt);
		Thread t2 = new Thread(tt);
		Thread t3 = new Thread(tt);
		
		t1.start();
		t2.start();
		t3.start();
	}
}

继承Thread 和实现Runnable的区别

1、继承有局限，Java中类只能够单继承
2、实现方式，我们的类在业务上可以继承它本应该有的类，同时可以实现接口变成一个线程类
3、关于数据共享的问题：就看所谓被共享的数据所在的类的对象被创建了几个

线程的其它概念

一、线程休眠sleep
static void sleep(long millis) //在指定的毫秒数内让当前正在执行的线程休眠
*注意不要在主线程中直接使用

Frame f = new Frame();
		Label label = new Label("10");
		label.setBackground(Color.RED);
		// 字体对象
		Font font = new Font("宋体",Font.BOLD,666);
		label.setFont(font);
		label.setAlignment(Label.CENTER);
		f.add(label);
		
		f.setSize(780, 780);
		f.setLocationRelativeTo(null);
		f.setVisible(true);
		
		for (int i = 10; i >= 0; i--) {
			label.setText(i+"");
			Thread.sleep(1000);    //每次等待1000毫秒
		}
}

二、线程的优先级
int getPriority() //返回线程的优先级
void setPriority(int newPriority) //更改线程的优先级
*线程的默认优先级和创建它的环境线程的当前优先级一致，主线程的默认优先级是5

三、守护线程
1、守护线程（精灵线程/后台线程）
每个线程都可以或不可以标记为一个守护程序
后台线程仅仅就是对线程的一个分类或者标记
2、特点：
① 一般来说后台线程是为前台线程服务的（例如gc线程）；
② 如果所有的前台线程都死了，那么后台线程也会自动的死亡；但是前台线程死了，后台线程不一定立即死亡（可能还需要收尸…）
③ 一个线程的默认状态和创建它的环境线程状态一致

3、测试把一个线程标记为后台线程
① 相关的方法：
boolean isDaemon() 测试该线程是否为守护线程
void setDaemon(boolean on) 将该线程标记为守护线程或用户线程
如果上面的参数为true 表示是后台线程
② 先以主线程来进行测试：1获得 2 尝试修改
③ 自定义的线程： 1 获得 2 尝试修改

线程同步

线程同步用于解决线程安全问题

线程同步方式一：同步代码块

1、基本语法结构

synchronize（同步监听对象）{
    需要被同步的代码（有线程安全问题的代码）
}

上面的结构相当于会把{}中的代码捆绑起来，看成是一个整体，一个线程执行完毕后其他的线程才能进来
2、语法特点：
① 同步监听对象理论上可以是任何的对象，但是必须保证多个线程访问到的是同一个同步监听对象；
② 很多时候可以直接使用this或是类的字节码对象 例如 String.class

线程同步方式二：同步方法
1、使用到synchronize 直接修饰一个方法就可以了；
2、位置，在方法的返回值类型前面；
3、同步方法不需要写同步监听对象，实例方法（非static修饰）默认同步监听对象是this;
4、同步方法不需要写同步监听对象，静态方法（有static修饰）默认同步监听对象是当前类所在的字节码对象 Xxx.class;

注意：此种方式要注意实例方法中的同步监听对象为this，若创建了多个实例对象则起不到同步的作用。

线程同步方式三：锁机制
使用Lock(接口)
–ReentrantLock(实现类)：与使用synchronized作用一致，但功能更强大(了解)
步骤：
1.创建ReentrantLock类对象
2.调用该对象的lock方法加锁
3.在合适的位置调用该对象的unlock()方法，释放锁
注意事项：建议把unlock方法，写在finally中，保证锁一定会被释放
方法：
lock():加锁
unlock():释放锁

public static void main(String[] args) {
	// 1.创建ReentrantLock类对象
	ReentrantLock rl = new ReentrantLock();
	// 2.调用该对象的lock方法加锁
	rl.lock();// 加锁
	try {
		System.out.println("被加锁的代码块");
	} catch (Exception e) {
	} finally {
		/*
		 * 3.在合适的位置调用该对象的unlock()方法，释放锁
		 * 注意事项：建议把unlock方法，写在finally中，保证锁一定会被释放
		 */
		rl.unlock();// 释放锁
	}
}