java tick_Java基础之线程

一、线程的基本概念

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。 如：运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的

线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 若一个程序可同一时间执行多个线程，就是支持多线程的。

进程与多线程：

什么时候需要多线程：

1、程序需要同时执行两个或多个任务。

2、程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

3、需要一些后台运行的程序时。

注意：每个Java程序都有一个隐含的主线程： main 方法

二、线程的创建与运行

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。

Thread类的特性：

每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体。

通过该Thread对象的start()方法来调用这个线程。

1、Thread类

构造方法

Thread()：创建新的Thread对象

Thread(String threadname)：创建线程并指定线程实例名

Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法

Thread(Runnable target, String name)：创建新的Thread对象

2、创建线程的两种方式

(1)、继承Thread类

1)、 定义子类继承Thread类。

2) 、子类中重写Thread类中的run方法。

3) 、创建Thread子类对象，即创建了线程对象。

4) 、调用线程对象start方法：启动线程，调用run方法。

public class MyThread extendsThread {public voidrun(){for (int a = 1; a < 10; a++){

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

}

}

}

public classTest_Thread {public static voidmain(String[] args) {for (int a = 1; a < 10; a++){

System.out.println(Thread.currentThread().getName()+ a);//主线程

}

MyThread myThread1= new MyThread();//开启第一个线程

myThread1.start();

MyThread myThread2= new MyThread();//开启第二个线程

myThread2.start();

MyThread myThread3= new MyThread();//开启第三个线程

myThread3.start();

}

}

.　　(2)、实现Runnable接口

1)、定义子类，实现Runnable接口。

2)、子类中重写Runnable接口中的run方法。

3)、通过Thread类含参构造器创建线程对象。

4)、将Runnable接口的子类对象作为实际参数传递给 Thread类的构造方法中。

5)、调用Thread类的start方法：开启线程，调用 Runnable子类接口的run方法。

public class MyThread implementsRunnable {int a = 30;

@Overridepublic voidrun() {for (int i = 0; i < a; i++){

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

}

}

}

public classTest_Thread {public static voidmain(String[] args) {for (int a = 0; a < 10; a++){

System.out.println(Thread.currentThread().getName()+a);//主线程

}

MyThread myThread= new MyThread();//创建线程对象

Thread thread1= new Thread(myThread);//开启第一个线程

thread1.start();

Thread thread2= new Thread(myThread);//开启第二个线程

thread2.start();

Thread thread3= new Thread(myThread);//开启第三个线程

thread3.start();

}

}

(3)、实现资源共享

public classTest_Thread {public static voidmain(String[] args) {for (int a = 0; a < 10; a++){

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

}

MyThread myThread= newMyThread();

Thread thread1= newThread(myThread);

thread1.start();

thread1.setPriority(Thread.MAX_PRIORITY);

Thread thread2= newThread(myThread);

thread2.start();

Thread thread3= newThread(myThread);

thread3.start();

thread3.setPriority(Thread.MIN_PRIORITY);

}

}

public class MyThread implementsRunnable{int a = 10;

@Overridepublic voidrun() {while (true){if (a < 0){break;

}

System.out.println(Thread.currentThread().getName()+ a--);

}

}

}

3、两种创建线程的区别与联系

(1)、继承Thread: 线程代码存放Thread子类run方法中。 实现Runnable：线程代码存在接口的子类的run方法。

(2)、实现方式创建线程的好处

1)避免了单继承的局限性

2)多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

4、Thread类的有关方法

(1)、第一类

void start(): 启动线程，并执行对象的run()方法

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

getName(): 返回线程的名称

void setName(String name):设置该线程名称

static currentThread(): 返回当前线程

(2)、第二类(线程的调度)

调度策略：

时间片：

抢占式：高优先级的线程抢占CPU

Java的调度方法： 同优先级线程组成先进先出队列(先到先服务)，使用时间片策略 对高优先级，使用优先调度的抢占式策略

线程的优先级控制：

MAX_PRIORITY(10);

MIN _PRIORITY (1);

NORM_PRIORITY (5);

涉及的方法： getPriority() ：返回线程优先值

setPriority(int newPriority) ：改变线程的优先级 线程创建时继承父线程的优先级

(3)、第三类

static void yield()：线程让步 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程 若队列中没有同优先级的线程，忽略此方法

join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止 低优先级的线程也可以获得执行

static void sleep(long millis)：(指定时间:毫秒) 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。 抛出InterruptedException异常

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

boolean isAlive()：返回boolean，判断线程是否还活着

5、线程的分类

Java中的线程分为两类：一种是守护线程，一种是用户线程。

它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。

守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。 Java垃圾回收就是一个典型的守护线程。 若JVM中都是守护线程，当前JVM将退出。

6、为什么要使用多线程

背景：只使用单个线程完成多个任务(调用多个方法)，肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

(1)多线程程序的优点： 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

(2)提高计算机系统CPU的利用率。

(3)改善程序结构，将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

7、线程的生命周期

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

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

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

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

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

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

三、线程的同步

多个线程执行的不确定性引起执行结果的不稳定 多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

举个例子：

(1)、你的账户上有3000元。有一个存折和一张卡对应的是这一个账户。

(2)、你去银行柜台取2000元，存折显示你账户有3000元，柜台员工正在给你办理。但是同时你的老婆在取款机上也取2000元，账户也显示有3000元。这样你们就取出4000元，这是很明显的错误。

(3)、解决办法就是，在你取钱的同时，你的账户是不允许有其他人取钱的，你取过钱，你的账户的钱减去2000元后，才能够其他取钱操作(资源独占)。

线程安全产生的原因：

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

解决办法：

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

packagemain.dyh.test_two;class Ticket implementsRunnable{private static int tick = 100;public voidrun(){while(true){if(tick>0){

System.out.println(Thread.currentThread().getName()+"售出车票，tick号为："+ tick--);try{

Thread.sleep(10);

}catch(InterruptedException e) {

e.printStackTrace();

}

}else{break;

}

}

}

}classTicketDemo{public static voidmain(String[] args) {

Ticket t= newTicket();

Thread t1= newThread(t);

Thread t2= newThread(t);

Thread t3= newThread(t);

t1.setName("t1窗口");

t2.setName("t2窗口");

t3.setName("t3窗口");

t1.start();

t2.start();

t3.start();

}

}

安全问题的解决：

Synchronized的使用方法：

(1)、synchronized (对象){

// 需要被同步的代码；

}

即有synchronized关键字修饰的方法。

由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。

synchronized还可以放在方法声明中，表示整个方法 为同步方法。 例如：

(2)、public synchronized void show (String name){

….

}

即有synchronized关键字修饰的语句块。

被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

注：同步是一种高开销的操作，因此应该尽量减少同步的内容。

通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

互斥锁：

在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。

每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。

关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。

同步的局限性：导致程序的执行效率要降低 同步方法(非静态的)的锁为this。

同步方法(静态的)的锁为当前类本身。

packagemain.dyh.test_two;class Ticket implementsRunnable{private static int tick = 100;public voidrun(){while(true){synchronized (this){if(tick>0){

System.out.println(Thread.currentThread().getName()+"售出车票，tick号为："+ tick--);try{

Thread.sleep(10);

}catch(InterruptedException e) {

e.printStackTrace();

}

}else

break;

}

}

}

}classTicketDemo{public static voidmain(String[] args) {

Ticket t= newTicket();

Thread t1= newThread(t);

Thread t2= newThread(t);

Thread t3= newThread(t);

t1.setName("t1窗口");

t2.setName("t2窗口");

t3.setName("t3窗口");

t1.start();

t2.start();

t3.start();

}

}

单例模式之懒汉模式：

classSingleton {private static Singleton instance = null;privateSingleton(){}public staticSingleton getInstance(){if(instance==null){synchronized(Singleton.class){if(instance == null){

instance=newSingleton();

} } }returninstance;

} }public classTestSingleton{public static voidmain(String[] args){

Singleton s1=Singleton.getInstance();

Singleton s2=Singleton.getInstance();

System.out.println(s1==s2);

} }

View Code

四、线程死锁

死锁：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

解决方法： 专门的算法、原则 尽量减少同步资源的定义

五、线程通信

wait() 与 notify() 和 notifyAll()

wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问

notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待

notifyAll ()：唤醒正在排队等待资源的所有线程结束等待

Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常

(1)、wait()

在当前线程中调用方法： 对象名.wait()

使当前线程进入等待(某对象)状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。

调用方法的必要条件：当前线程必须具有对该对象的监控权(加锁)

调用此方法后，当前线程将释放对象监控权 ，然后进入等待

在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

(2)、notify()与notifyAll()

在当前线程中调用方法： 对象名.notify()

功能：唤醒等待该对象监控权的一个线程。

调用方法的必要条件：当前线程必须具有对该对象的监控权(加锁)

经典案例：生产者消费者问题

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20)，如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

这里可能出现两个问题：

生产者比消费者快时，消费者会漏掉一些数据没有取到。

消费者比生产者快时，消费者会取相同的数据。

packagemain.dyh.test_two;public classTestProduct {public static voidmain(String[] args) {

Clerk clerk= newClerk();

Thread productorThread= new Thread(newProductor(clerk));

Thread consumerThread= new Thread(newConsumer(clerk));

productorThread.start();

consumerThread.start();

}

}class Clerk{ //售货员

private int product = 0;public synchronized voidaddProduct(){if(product >= 20){try{

wait();

}catch(InterruptedException e) {

e.printStackTrace();

}

}else{

product++;

System.out.println("生产者生产了第"+product+"个产品");

notifyAll();

}

}public synchronized voidgetProduct(){if(this.product <= 0){try{

wait();

}catch(InterruptedException e) {

e.printStackTrace();

}

}else{

System.out.println("消费者取走了第"+product+"个产品");

product--;

notifyAll();

}

}

}class Productor implements Runnable{ //生产者

Clerk clerk;publicProductor(Clerk clerk){this.clerk =clerk;

}public voidrun(){

System.out.println("生产者开始生产产品");while(true){try{

Thread.sleep((int)Math.random()*1000);

}catch(InterruptedException e) {

}

clerk.addProduct();

}

}

}class Consumer implements Runnable{ //消费者

Clerk clerk;publicConsumer(Clerk clerk){this.clerk =clerk;

}public voidrun(){

System.out.println("消费者开始取走产品");while(true){try{

Thread.sleep((int)Math.random()*1000);

}catch(InterruptedException e) {

}

clerk.getProduct();

}

}

}