java多线程学习总结

一、线程的基本概念

简单的说：线程就是一个程序里不同的执行路径，在同一个时间点上cpu只会有一个线程在执行，Java里的多线程是通过java.lang.Thread类来实现的，每个线程都拥有自己独立的方法栈空间。

二、java线程的创建和启动

第一种

定义线程类实现Runnable接口：

Thread myThread = new Thread(target) //target为Runnable接口类型

Runnable中只有一个方法：

public void run();用以定义线程运行体

第二种

可以定义一个Thread的子类并重写其run方法：

clas MyThread extends Thread{

public void run(){}

}

线程类必须通过执行Thread的start()方法启动一个新的线程，如果调用run()方法是属于方法的调用，不会启动一个新的线程，推荐使用第一种方式创建线程，使用接口较为灵活。

三、线程状态装换

调用线程start()方法时，线程进入就绪状态，Cpu分配时间片，线程进入运行状态，时间片结束，run()方法未执行完，线程进入阻塞状态。

四、线程控制基本方法

isAlive() //判断线程是否还“活着”，即线程是否还未终止

getPriority() //获得线程的优先级数值

setPriority() //设置线程的优先级指数

Thread.sleep() //静态方法，将当前线程睡眠指定毫秒数

join() //调用某线程的该方法，将当前线程与该线程合并，

/ /即等待该线程结束，再回复当前线程的运行。

yield() //让出CPU，当前线程进入就绪状态等待调度

interrupt() //中断线程

wait() //当前线程进入对象的wait pool

notify()/all //唤醒对象的wait pool中的一个/所有等待线程

五、sleep方法

Thread的静态方法

public static void sleep(long millis) throws InterruptedException 必须对异常进行捕捉

Thread.currentThread();//拿到当前线程

六、interrupt方法一种让线程退出的方式。

import java.util.*;

public class TestInterrupt{

public static void main(String[] args){

MyThread t = new MyThread();

t.start();

try{Thread.sleep(10000);}

catch(InterruptedException i){}

t.interrupt();

}

}

class MyThread extends Thread{

public void run(){

while(true){

try{

System.out.println("------"+new Date()+"-----");

Thread.sleep(1000);

}catch(InterruptedException i){

return;

}

}

}

}

七、join和yield方法

t.join(); //t的run()方法完才会继续执行当前线程方法体

//也就是两个线程变成了一个线程

t.yield(); //暂停当前正在执行的线程对象，并执行其他线程。方法为静态

//哪个线程体执行此方法，哪个线程让步

public class TestYield {

public static void main(String[] args) {

MyThread3 t1 = new MyThread3("t1");

MyThread3 t2 = new MyThread3("t2");

t1.start();

t2.start();

}

}

class MyThread3 extends Thread {

MyThread3(String s){super(s);}

public void run(){

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

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

if(i%10==0){

yield();

}

}

}

}

八、线程优先级别

线程的优先级用数字表示，范围从1到10，一个线程的缺省优先级为5.

Thread.MAX_PRIORITY=1

Thread.MIN_PRIORITY=10

Thread.NORM_PRIORITY=5

例：t.setPriority(Thread.NORM_PRIORITY+3);

九、线程同步

1.同步代码块

synchronized(this){ //在执行代码块过程中，不会被其他线程打断

...

}

public sunchronized void method //执行此方法时，当前对象被锁定

在Java语言中，引入了对象互斥锁的概念，保证共享数据操作的完整性，每个对象 都对应一个可称为"互斥锁"的标记，这个标记保证在任一时刻，只能有一个线程访 问该对象。

2.线程死锁

public class TestDeadLock implements Runnable {

public int flag = 1;

static Object o1 = new Object(), o2 = new Object();

public void run() {

System.out.println("flag=" + flag);

if(flag == 1) {

synchronized(o1) {

try {

Thread.sleep(500);

} catch (Exception e) {

e.printStackTrace();

}

synchronized(o2) {

System.out.println("1");

}

}

}

if(flag == 0) {

synchronized(o2) {

try {

Thread.sleep(500);

} catch (Exception e) {

e.printStackTrace();

}

synchronized(o1) {

System.out.println("0");

}

}

}

}

public static void main(String[] args) {

TestDeadLock td1 = new TestDeadLock();

TestDeadLock td2 = new TestDeadLock();

td1.flag = 1;

td2.flag = 0;

Thread t1 = new Thread(td1);

Thread t2 = new Thread(td2);

t1.start();

t2.start();

}

}

十、生产者消费者问题

public class ProducerConsumer {

public static void main(String[] args) {

SyncStack ss = new SyncStack();

Producer p = new Producer(ss);

Consumer c = new Consumer(ss);

new Thread(p).start();

new Thread(p).start();

new Thread(p).start();

new Thread(c).start();

}

}

class WoTou {

int id;

WoTou(int id) {

this.id = id;

}

public String toString() {

return "WoTou : " + id;

}

}

class SyncStack { //栈实现

int index = 0;

WoTou[] arrWT = new WoTou[6]; //相当于装物品的篮子

public synchronized void push(WoTou wt) { //生产物品，线程安全

while(index == arrWT.length) { //当篮子满了线程等待

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

this.notifyAll(); //开始生产时，叫醒等待的其他线程开始消费

arrWT[index] = wt;

index ++;

}

public synchronized WoTou pop() { //消费物品，线程安全

while(index == 0) { //如果篮子空了

try {

this.wait(); //线程等待,等待生产者开始

//生产，叫醒此线程

} catch (InterruptedException e) {

e.printStackTrace();

}

}

this.notifyAll(); //消费时喊醒生产者生产

index--;

return arrWT[index];

}

}

class Producer implements Runnable { //生产者类

SyncStack ss = null;

Producer(SyncStack ss) {

this.ss = ss;

}

public void run() {

for(int i=0; i<20; i++) { //生产20个

WoTou wt = new WoTou(i);

ss.push(wt);

System.out.println("生产了：" + wt);

try {

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

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

class Consumer implements Runnable {

SyncStack ss = null;

Consumer(SyncStack ss) {

this.ss = ss;

}

public void run() {

for(int i=0; i<20; i++) { //消费20个

WoTou wt = ss.pop();

System.out.println("消费了: " + wt);

try {

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

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}