1.MAX_PRIORITY:10
NORM_PRIORITY:5
MIN_PRIORITY:1
2.获取和设置当前线程的优先级
getPriority：获取线程的优先级
setPriority(int p):设置线程的优先级
说明：高优先级的线程要抢占低优先级线程cpu的执行权。但只是从概率上来讲，高优先级的线程高概率的情况下被执行，并不意味着只有当高优先级的线程被执行完以后，低优先级的线程才被执行
方式二：实现Runnable接口1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的对象调用start()
package shangGuiGu.day21;
//创建三个窗口卖票，总票数为100票
class window extends Thread{
private static int ticket=100;
public void run(){
while(true){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+":卖票，票号为"+ticket);
ticket--;
}else{
break;
}
}
}
}
public class demo02 {
public static void main(String[] args) {
window w1=new window();
window w2=new window();
window w3=new window();
w1.setName("窗口1");
w1.setName("窗口2");
w1.setName("窗口3");
w1.start();
w2.start();
w3.start();
}
}
package shangGuiGu.day21;
class mthread implements Runnable{
public void run(){
for(int i=0;i<100;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class demo03 {
public static void main(String[] args) {
mthread mthread=new mthread();
Thread t1 = new Thread(mthread);
t1.start();
t1.setName("线程1");
Thread t2 = new Thread(mthread);
t2.start();
t2.setName("线程二");
}
}
package shangGuiGu.day21;
//创建三个窗口卖票，总票数为100票，使用实现Runnable接口的方式
class window1 implements Runnable{
private int ticket=100;
public void run(){
while(true){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"卖票，票号为："+ticket);
ticket--;
}else{
break;
}
}
}
}
public class demo01 {
public static void main(String[] args) {
window1 w=new window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t1.setName("窗口2");
t1.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
比较创建线程的两种方式
开发中，优先选择实现Runnable接口的方式
原因：1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合来处理多个线程有共享数据的情况
联系：public class Thread implements Runnable
相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中
线程的安全问题1.问题：买票过程中，出现了重票、错票
2.出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
3.解决问题：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
4.在java中通过同步机制来解决线程安全问题
方式一：同步代码块
synchronize（同步监视器）
{//需要被同步的代码
}
说明：1.操作共享数据的代码即为需要被同步的代码
2.共享数据：多个线程共同操作的变量。例如：ticket
3.同步监视器，俗称：锁。任何一个类的对象都可以充当锁。要求：多个线程必须要共用同一把锁
补充：在实现Runnable接口创建多线程的方式中，可以考虑使用this充当同步监视器
方式二：同步方法
若操作共享数据的代码完整的声明在一个方法中，不妨将此方法声明同步的
package shangGuiGu.day21;
class window2 implements Runnable{
private int ticket=100;
Object obj=new Object();
public void run(){
show();
}
private synchronized void show(){//同步监视器：this
while(true){
synchronized(obj){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"卖票，票号为："+ticket);
ticket--;
}
}}
}
}
public class demo04 {
public static void main(String[] args) {
window1 w=new window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t1.setName("窗口2");
t1.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
关于同步方法的总结：
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
2.非静态的同步方法，同步监视器是this
静态的同步方法，同步监视器是当前类本身
死锁问题1.理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
2.说明：①出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
②使用同步时，要避免出现死锁
方法三：Lock锁
package shangGuiGu.day21;
import java.util.concurrent.locks.ReentrantLock;
class windoww implements Runnable{
private int ticket=100;
//1.实例化ReentrantLock
private ReentrantLock lock1=new ReentrantLock(true);
Object obj=new Object();
public void run(){
while(true){
try{
//调用锁定lock方法
lock1.lock();
if(ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖票，票号为："+ticket);
ticket--;
}else{
break;
}
}finally {
//调用解锁方法:unlock
lock1.unlock();
}
}
}
}
public class demo07 {
public static void main(String[] args) {
window1 w=new window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t1.setName("窗口2");
t1.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
synchronized与lock方法的不同：
synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
lock需要手动的启动同步（lock),同时结束同步也需要手动的实现（unlock）
package shangGuiGu.day21;
class account{
private double balance;
public account(double balance) {
this.balance = balance;
}
//存钱
public synchronized void deposit(double amt){
if(amt>0){
balance+=amt;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"存钱成功，余额为："+balance);
}
}
}
class customer extends Thread{
private account a1;
public customer(account acct) {
this.a1=acct;
}
public void run(){
for(int i=0;i<3;i++){
a1.deposit(1000);
}
}
}
public class demo08 {
public static void main(String[] args) {
account acct=new account(0);
customer c1 = new customer(acct);
customer c2 = new customer(acct);
c1.setName("甲");
c2.setName("乙");
c1.start();
c2.start();
}
}
线程的通信
涉及到的三个方法：
wait：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
notify：一旦执行此方法，就会唤醒被wait的一个线程。若有多个线程被wait，就唤醒优先级高的线程
notifyall：一旦执行此方法，就会唤醒所有被wait的线程
说明：
1.三种方法必须使用在同步代码块或同步方法中。
2.三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现illegalmonitorstateexception异常
3.三个方法是定义在object类中
package shangGuiGu.day21;
class number implements Runnable{
private int number1=1;
public void run(){
while(true){
synchronized (this){
notify();
if(number1<=100){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+number1);
number1++;
try {
//使得调用如下wait方法的线程进入阻塞状态
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
break;
}}
}
}
}
public class demo09 {
public static void main(String[] args) {
number number2 = new number();
Thread t1=new Thread(number2);
Thread t2=new Thread(number2);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
