java基础 我的线程初次学习
线程的基本概念：
线程是一个程序内部的顺序控制流。
线程与进程的区别：
- 每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销。
- 线程可以看成轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换的开销小。
- 多进程：在操作系统中能同时运行多个任务（程序）
- 多线程：在同意应用程序中有多个顺序流同时执行
Java的线程是通过java.lang.Tread类来实现的
VM（Java虚拟机）启动时会有一个由主方法（public static void main(）{}）所定义的线程。
可以通过创建Tread的实例来创建新的线程。
每个线程都是通过某个特定Tread对象所对应的方法run()来完成其操作的，方法run()成为线程体
通过调用Thead类的start()方法来启动一个线程
线程的创建和启动
有两种方式创建新的线程。
第一种：
- 定义线程类实现Runnable接口
- Thread myTread = new Thread(target) //target为Runnable接口类型.
- Runnable中只有一个方法:public void run();//用以定义线程运行体
- 使用Runnable接口可以为多个线程提供共享的数据。
- 在实现Runnable接口的类的run方法定义中可以使用Tread的静态方法：public static Thread currentThread()获取当前线程的引用。
public class TestThread1{
public static void main(String[] args){
Runner1 r = new Runner1();
Thread m = new Thread(r);
m.start();
for(int i=1;i<=100;i++){
System.out.println("MainThread i: "+i);
}
}
}
class Runner1 implements Runnable{
public void run()
{
for(int i=1;i<=100;i++){
System.out.println("Runner1 i: "+i);
}
}
}
第二种：
- 可以定义一个Thread的子类并重写其run方法如：
class MyThread extends Thread{
public void run()
}
}
- 然后生成该类的对象:
- MyThread myThread=new MyTread(...)
public class TestThread1{
public static void main(String[] args){
Runner1 r = new Runner1();
//Thread m = new Thread(r);
r.start();
for(int i=1;i<=100;i++){
System.out.println("MainThread i: "+i);
}
}
}
class Runner1 extends Thread{
public void run()
{
for(int i=1;i<=100;i++){
System.out.println("Runner1 i: "+i);
}
}
}
注意：尽量能使用implements Runnable接口就尽量使用接口
线程状态：
线程控制基本方法
方法 |
功能 |
| isAlive() | 判断线程是否还“活着”,即线程是否还未终止。 |
| getPriority() | 获得线程的优先级数值。 |
| setPriority() | 设置线程的优先级数值。 |
| Thread.sleep() | 将当前线程睡眠指定毫秒数。 |
| join() | 调用某线程的该方法，将当前线程与该线程“合并”，即等待该线程结束，再恢复当前线程的运行。 |
| yield() | 让出CPU，当前线程进入就绪队列等待调度。 |
| wait() | 当前线程进入对象的wait pool。 |
|
notify()/
notifyAll()
|
唤醒对象的wait pool中的一个/所有等待线程 |
sleep方法：
- 可以调用Thread的静态方法：
- public static void sleep(long millis) throws InterruptedException（使得当前线程休眠，暂时停止执行millis毫秒）
- 由于是静态方法，sleep可以由类名直接调用:Thread.sleep()
//每隔一秒钟打印时间，主函数睡眠10秒后打断run1这个类使得它停止
import java.util.*; //调用Date()
public class TestInterrupt{
public static void main(String []args){
run1 r = new run1();
r.start();
try{
Thread.sleep(10000);
}catch(InterruptedException e){}
r.interrupt();
}
}
class run1 extends Thread{
public void run(){
while(true){
System.out.println("---"+new Date()+"---");
try{
sleep(1000);
}catch(InterruptedException e){
return;
}
}
}
}
join方法：
- 合并某个线程
public class TestJoin{
public static void main(String[] args){
MyThread2 t2 = new MyThread2("t2");
t2.start();
try{
t2.join(); //会先执行完t2，才会执行下面的代码
}catch(InterruptedException e){return;}
for(int i = 0;i<=10;i++){
System.out.println("Main: "+i);
}
}
}
class MyThread2 extends Thread{
MyThread2(String s){
super(s);
}
public void run(){
for(int i = 0;i<=10;i++){
try{
sleep(1000);
}catch(InterruptedException e){return;}
System.out.println(getName()+" :"+i);
}
}
}
yield方法
- 让出CPU给其他线程执行的机会
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=0;i<100;i++){
System.out.println(getName()+": "+i);
if(i%10==0){
yield(); 暂时让其他线程执行多一些
}
}
}
}
线程的优先级：
- 线程的优先级用数字表示，范围从1到10，一个线程的缺省优先级是5.
- Thread.MIN_PRIORITY=1
- Thread.MAX_PRIORITY=10
- Thread.NORM_PRIORITY=5
- 使用下述线程的方法获得或设置线程对象的优先级。
- int getPriority();
- void setPriority(int newPriority);
public class TestPriority{
public static void main(String[] args){
T1 t1 = new T1();
T2 t2 = new T2();
Thread tt1 = new Thread(t1);
Thread tt2 = new Thread(t2);
tt1.setPriority(Thread.NORM_PRIORITY +3);
tt1.start();
tt2.start();
}
}
class T1 implements Runnable{
public void run(){
for(int i=0;i<1000;i++){
System.out.println("T1: "+i);
}
}
}
class T2 implements Runnable{
public void run(){
for(int i=0;i<1000;i++){
System.out.println("----T2: "+i);
}
}
}
正确的停止线程的方法：
public class TestThread4{
public static void main(String[] args){
Runner3 r = new Runner3();
Thread t = new Thread(r);
t.start();
for(int i=0;i<100;i++){
System.out.println("in thread main i="+i);
}
System.out.println("Thread main is over");
r.shutDown();
}
}
class Runner3 implements Runnable{
private boolean flag = true;
public void run(){
int i=0;
while(flag==true){
i++;
System.out.println(" "+i);
}
}
public void shutDown(){
flag=false;
}
}
线程同步：
当某个对象被synchronized修饰时，表明该对象在任一时刻只能由一个线程访问（通俗来讲，该这里被锁住了）
public class TestSync implements Runnable{
Timer timer = new Timer();
public static void main(String[] args){
TestSync test = new Thread(test);
Thread t1 = new Thread(test);
Thread t2 = new Thread(test);
t1.start();
t2.start();
}
public void run(){
timer.add(Thread.currentThread().getName());
}
}
class Timer{
private static int num=0;
public void add(String name){
锁的第一种写法： synchronized (this){
num++;
try{Thread.sleep(1);}
catch(InterruptedException e){}
System.out.println(name+", 你是第"+num+"个使用timer的线程")；
}
}
}
class Timer{
private static int num=0;
锁的第二种写法： public synchronized void add(String name){
num++;
try{Thread.sleep(1);}
catch(InterruptedException e){}
System.out.println(name+", 你是第"+num+"个使用timer的线程")；
}
}
如果高亮的地方被注释，也就是没有加锁，输出结果是两个 ：你是第2个使用timer的线程
否则被锁住才会输出：你是1个使用timer的线程\n 你是第2个使用timer的线程
注意：死锁（互斥锁）
：
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 class TT implements Runnable{
int b =100;
public synchronized void m1() throws Exception{
b=1000;
Thread.sleep(5000);
System.out.println("b= "+b);
}
public void m2(){
System.out.println(b);
}
public void run(){
try{
m1();
} catch(Exception e){
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception{
TT tt = new TT();
Thread t = new Thread(tt);
t.start();
Thread.sleep(1000);
tt.m2();
System.out.println(tt.b);
}
}
结果：1000\n 1000
public class TT implements Runnable{
int b =100;
public synchronized void m1() throws Exception{ //只是保证只有一个线程使用这个方法，其他的方法依然可以使用
b=1000;
Thread.sleep(5000);
System.out.println("b= "+b);
}
public void m2()throws Exception{
Thread.sleep(2500);
b=2000;
}
public void run(){
try{
m1();
} catch(Exception e){
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception{
TT tt = new TT();
Thread t = new Thread(tt);
t.start();
tt.m2();
}
}
结果：2000
public class TT implements Runnable{
int b =100;
public synchronized void m1() throws Exception{
b=1000;
Thread.sleep(5000);
System.out.println("b= "+b);
}
public synchronized void m2()throws Exception{
Thread.sleep(2500);
b=2000;
}
public void run(){
try{
m1();
} catch(Exception e){
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception{
TT tt = new TT();
Thread t = new Thread(tt);
t.start();
tt.m2();
System.out.println(tt.b);
}
}
结果 ：1000/n b=1000
notify不能叫醒自己！！！
经典生产包子 消费包子同时进行的问题。考察到了wait(),notify(),sychronized等语法
//一个线程生产包子，一个线程消费包子
//注意栈的用到
public class ProducerConsumer{
public static void main(String[] args){
wtStack ww = new wtStack();
producer p1 = new producer(ww);
consumer c1 = new consumer(ww);
Thread p = new Thread(p1);
Thread c = new Thread(c1);
p.start();
c.start();
}
}
class wotou{
int id;
wotou(int id){
this.id=id;
}
public String toString(){
return "wotou's id :"+id;
}
}
class wtStack{
int index=0;
wotou[] wotous= new wotou[6];
public synchronized void push(wotou ww){
while(index==wotous.length){
try{
this.wait(); //使得当前的线程暂停
}catch(InterruptedException e){
e.printStackTrace();
}
}
this.notify(); //唤醒一个其他的wait的线程 如果是notifyAll()则为唤醒其他所有的wait线程
wotous[index]=ww;
index++;
}
public synchronized wotou pop(){
while(index==0){
try{
this.wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
this.notify();
index--;
return wotous[index];
}
}
class producer implements Runnable{
wtStack ww = null;
producer(wtStack ww){
this.ww=ww;
}
public void run(){
for(int i=0;i<20;i++){
wotou temp = new wotou(i);
System.out.println("生产了："+temp);
ww.push(temp);
/*try{
Thread.sleep((int)(Math.random()*20));
}catch(InterruptedException e){
e.printStackTrace();
}
*/
}
}
}
class consumer implements Runnable{
wtStack ww = null;
consumer(wtStack ww){
this.ww=ww;
}
public void run(){
for(int i=0;i<20;i++){
wotou temp = null;
temp=ww.pop();
System.out.println("消费了"+temp);
}
/*try{
Thread.sleep((int)(Math.random()*20));
}catch(InterruptedException e){
e.printStackTrace();
}
*/
}
}