Javase——多线程

多线程

程序：一段静态代码

进程：加载到内存中的正在运行中的程序，一个程序可以启动多个进程

线程：进程中子任务，线程间通信非常容易

 

java.lang.Thread类来表示

入口方法是run()

启动方法是start()

 

创建并启动线程的步骤

方式一：实现Runnable接口

• 写一个具体类，实现Runnable接口，重写run()方法
• 创建这个类的对象，将对象作为实际参数传递给Thread类的构造方法，创建线程对象
• 调用线程对象的start方法

class HelloRunnable implements Runnable{

    @Override

    public void run() {

        for(int i = 0;i<100;i++) {

            System.out.println(i);

            System.out.println(Thread.currentThread().getName());

        }

    }

}



public class RunnableTest {

    public static void main(String[] args) {

        Runnable runnable = new HelloRunnable2();

        Thread thread = new Thread(runnable);

        thread.start();//启动子线程

        for(int i=0;i<100;i++) {

            if(i%2==1) {

                System.out.println(Thread.currentThread().getName()+":"+i);

            }

        }

    }

 

方式二：继承Thread类

• 写一个具体类，继承Thread，重写run方法
• 创建具体子类对象，就相当于创建了线程对象
• 调用对象的Start方法

class MyThread extends Thread{

    @Override
    public void run() {

        for(int i = 0;i<100;i++) {

            System.out.println(Thread.currentThread().getName()+":"+ i);

        }

    }

}



public class ThreadTest {

    public static void main(String[] args) {

        MyThread myThread = new MyThread();

        myThread.start();

        for(int i = 0;i<100;i++) {
    
            System.out.println(Thread.currentThread().getName()+":"+ i);

        }

    }

}

Thread类的有关方法1

start() 启动线程，并执行对象的run() 方法 --->这个是自动调用

run() 线程在被调度时执行的操作

getName() 返回该线程的名称

setName() 设置该线程名称

currentThread() 返回当前线程

 

Thread类的有关方法2

static void yield() 线程让步

join（）让某个程序执行流中调用其他线程的join()方法

static void sleep(long millis) 让当前线程睡眠，那个栈压这个方法，哪个栈睡眠

stop(): 强制线程生命周期结束

isAlive() 强制线程生命期结束

 

多线程的优点：

• 提高应用程序的响应。对图形化界面更有意义，可增强用户体验
• 提高计算机系统CPU的利用率
• 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

 

 

解除阻塞：

1）时间到

2）被别的线程调用了本线程对象的interrupt方法

 

 

线程的生命周期：

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态

 

• 新建

当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态

• 就绪

处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件

• 运行

当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能

• 阻塞

在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态

• 死亡

线程完成了它的全部工作或线程被提前强制性地中止

 

线程的同步

多线程安全问题：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与进来执行，导致共享数据的错误。

解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

线程安全问题的解决方式

Synchronized的使用方法

互斥锁

释放锁

死锁问题

 

银行账户存钱取钱——用多线程模拟

class Acount {
	private String name;
	private int balance;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getBalance() {
		return balance;
	}
	public void setBalance(int balance) {
		this.balance = balance;
	}
	/**
	 * @param name
	 * @param balance
	 */
	public Acount(String name, int balance) {
		super();
		this.name = name;
		this.balance = balance;
	}
//	@Override
//	public String toString() {
//		return "Acount [name=" + name + ", balance=" + balance + "]";
//	}
	
}

class Deposit implements Runnable{
	private Acount acount;
	public Acount getAcount() {
		return acount;
	}
	public void setAcount(Acount acount) {
		this.acount = acount;
	}
	/**
	 * @param acount
	 */
	public Deposit(Acount acount) {
		super();
		this.acount = acount;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<3;i++) {
			synchronized ("") {
				acount.setBalance(acount.getBalance()+1000);
				System.out.println(Thread.currentThread().getName()+":"+acount.getBalance());
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}
	
}
//另一个柜台Withdraw取3000元, 每次取1000,取3次
class Withdraw implements Runnable{
	private Acount acount;
	@Override
	public void run() {
		for(int i=0;i<3;i++) {
			if(acount.getBalance()==0) {
				try {
					System.out.println("没钱取不了");
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}else {
				acount.setBalance(acount.getBalance()-1000);
				System.out.println(Thread.currentThread().getName()+":"+acount.getBalance());
			}
		}
	}
	/**
	 * @param acount
	 */
	public Withdraw(Acount acount) {
		super();
		this.acount = acount;
	}
}

public class AcountTest{
//	public static void main1(String[] args) {
//		Acount acount = new Acount("小明",0);
//		Runnable runner = new Deposit(acount);
//		Thread thread1 = new Thread(runner);
//		thread1.start();
//		Thread thread2 = new Thread(runner);
//		thread2.start();
//	}
	public static void main(String[] args) {
		Acount acount = new Acount("小强",0);
		Runnable runner1 = new Deposit(acount);
		Thread thread1 = new Thread(runner1);
		thread1.setName("线程1");
		thread1.start();
		Runnable runner2 = new Withdraw(acount);
		Thread thread2 = new Thread(runner2);
		thread2.setName("线程2");
		thread2.start();
	}
	
	
}