java---Thread多线程（上）

public class Demo {

public static void main(String[] args) {

	// =====================Thread多线程===================================
	//
	/**
	 * 多线程实现方法1 1、创建一个类，继承Thread类，重写run()方法, 2、实现这个类，调用start()方法启动一个线程
	 */
	MyThread mt = new MyThread();
	mt.start();

	/**
	 * 多线程实现方法2 1、声明实现Runnable接口类，并重写run()方法 2、在创建Thread作为一个参数传递，并启动线程
	 */
	Mythread2 mt2 = new Mythread2();
	Thread t = new Thread(mt2);
	t.start();

	/**
	 * 两种方法的区别 继承Thread：由于子类重写了Thread类的run()方法，当调用start()时直接找子类的run()方法
	 * 实现Runnable：构造函数中传入了Runnable的引用，成员变量记住了它，start()调用run()方法时内部判断
	 * 成员变量Runnable的引用是否为空，不为空编译时看的Runnable的run()方法，运行时执行的 是子类的run()方法
	 */

	/**
	 * 优缺点 继承Thread： 优点：可以直接使用Thread类的run()，当调用start()时，直接找子类的run()方法
	 * 缺点：如果已经有了继承父类，就不能实现这种方法 实现Runnable：
	 * 优点：即使自己定义的线程类有了父类也没关系，因为有了父类也可以实现接口，而且接口可以多实现
	 * 缺点：不能直接使用Thread中的方法，需要先获取到线程对象后，才能得到Thread的方法，代码复杂
	 */

	/**
	 * 匿名内部类实现线程的两种方式 1 * 继承Thread类
	 */
	new Thread() {
		public void run() {
			// TODO Auto-generated method stub
		};
	}.start();

	/**
	 * 匿名内部类实现线程的两种方式 2 * 实现Runnable接口
	 */
	new Thread(new Runnable() {
		@Override
		public void run() {
			// TODO Auto-generated method stub
		}
	}).start();

	/**
	 * 获取名字 * getName()方法
	 */
	String nameString = t.getName();

	/**
	 * 设置名字 *通过构造函数可以传入String类型的名字
	 */
	new Thread("name") {
		public void run() {
		};
	}.start();
	/**
	 * 设置名字 *通过setName(String str);方法设置线程对象的名字
	 */
	Thread t2 = new Thread() {
		public void run() {
		};
	};
	t2.setName("name");
	t2.start();

	/**
	 * 获取当前线程对象 *Thread.currentThread()，主线程也可以获取
	 */
	Thread.currentThread().getName();

	/**
	 * 休眠线程 *Thread.sleep(毫秒，纳秒)
	 */
	Thread.sleep(1000);

	/**
	 * 守护进程 *etDaemon();
	 */
	t2.setDaemon(true);

	/**
	 * 多线程加入 *join(); join(int);加入固定时间，过了固定时间则继续交替执行
	 */
	final Thread t1 = new Thread() {
		@Override
		public void run() {
			for (int i = 0; i < 10; i++) {
				System.out.println(getName() + "aaa");
			}
		}
	};

	Thread t3 = new Thread() {
		@Override
		public void run() {
			for (int i = 0; i < 10; i++) {
				if (i == 2) {
					t1.join();// 匿名内部类在使用所在方法中的成员变量时，成员变量必须使用final修饰
				}
				System.out.println(getName() + "bb");
			}
		}
	};

	/**
	 * 礼让线程 *Thread.yield()让出cpu;
	 */

	/**
	 * 设置线程优先级 *setPriority();
	 */
	t3.setPriority(10);

	/**
	 * 多线程线程安全问题
	 * 继承Thread类
	 * 锁对象用Ticket1.class
	 */
	new Ticket1().start();
	new Ticket1().start();
	new Ticket1().start();
	new Ticket1().start();
	
	/**
	 * 多线程线程安全问题
	 * 实现Runnable接口
	 * 锁对象用Ticket1.class，也可以用this
	 */
	MyTicket3 mt3 = new MyTicket3();
	new Thread(mt3).start();
	new Thread(mt3).start();
	new Thread(mt3).start();
	new Thread(mt3).start();

}

}

class MyTicket3 implements Runnable{
private int ticket2 = 100;
@Override
public void run() {
	while (true) {
		synchronized (MyTicket3.class) {
			if (ticket2 <= 0) {
				break;
			}
			System.out.println(Thread.currentThread().getName() + ":这是第" + ticket2-- + "号票");
		}
	
}

}

class Ticket1 extends Thread {
private static int ticket = 100;

@Override
public void run() {
	while (true) {
		synchronized (Ticket1.class) {
			if (ticket <= 0) {
				break;
			}
			System.out.println(getName() + ":这是第" + ticket-- + "号票");
		}
		

	}
}
}

/**
* 同步方法 *synchronized(){}; 只需要在方法上加synchronized关键字 非静态的同步方法的锁对象是this
 * 静态的同步方法锁对象是该类的字节码对象（Printer2.class）
*/
class Printer2 {
public static synchronized Void print4() {
	synchronized (Printer2.class) {
		// TODO Auto-generated method stub
	}

}

public synchronized void print2() {
	// TODO Auto-generated method stub
}

public void print3() {
	synchronized (this) {
		// TODO Auto-generated method stub
	}

}

}

/**
 * 同步代码块 *synchronized(){}; 采用synchronized关键字再加上一个所对象来定义一段代码段
* 多个同步代码块如果使用相同的所对象，那么它们就是同步的 所对象不能用匿名对象，匿名对象不是同一个对象
 */
class Printer {
Demo d = new Demo();

public void print() {
	synchronized (d) {
		// TODO Auto-generated method stub
	}
}
}

class MyThread extends Thread {
@Override
public void run() {
	// TODO Auto-generated method stub
}
}

class Mythread2 implements Runnable {

@Override
public void run() {
	// TODO Auto-generated method stub

}

}