JAVA

java多线程

　　java多线程….笔记

多线程实现方式一

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
创建多线程：
	方式一：继承Thread类
		A:自定义MyThread类继承Thread
		B:MyThread类里面重写run()
		C:创建对象
		D:启动线程
```	
```java
//MyThread.java
public class MyThread extends Thread  {
	@Override
	public void run() {
		long start=System.currentTimeMillis();
		for(int i=0;i<1000;i++){
			System.out.println(i);
		}
		long end=System.currentTimeMillis();
		System.out.println("--------------------");
		System.out.println(end-start+"毫秒");
	}
}
1
2
3
4
5
6
7
8
9
10
11
//MyThreadDemo.java
public class MyThreadDemo{
	public static void main(String[] args) {
		
		 MyThread my1=new MyThread();
		 MyThread my2=new MyThread();
		 my1.start();
		 my2.start();
		
	}
}

线程的名称

　　String getName()//返回该线程的名称。
　　void setName(String name)//设置线程名称，使之与参数 name 相同。

获取当前线程对象

　　static Thread currentThread()//返回对当前正在执行的线程对象的引用。

线程调度

　　两种调度模型：分时调度，抢占式调度
　　java使用的抢占式调度模型,与优先级有关。

优先级

　　int getPriority()//返回线程的优先级，默认为5
　　int setPriority()//设置线程的优先级
　　优先级默认范围：1-10，次数较多时才比较有效果，因为存在随机性

线程控制

　　static void sleep(long millis)//在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
　　void join()//等待该线程终止
　　static void yield()//暂停当前正在执行的线程对象，并执行其他线程。
　　void setDaemon(boolean on)//将该线程标记为守护线程或用户线程。
　　void stop()//已过时,但是还可以用
　　public void 　　interrupt()中断线程，把线程状态终止，并抛出一个异常，然后执行完后续代码

线程的生命周期

  • 新建：创建线程对象
  • 就绪：有执行资格，没有执行权
  • 运行：有执行资格，有执行权
  • 死亡：线程对象编程垃圾，等待被回收
  • 阻塞：没有执行资格，没有执行权，但是可以被激活，激活后处于就绪状态

线程生命周期.png

多线程实现方式二

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
创建多线程：
	方式二：实现Runnable接口
		A:自定义MyRunnable实现Runnable接口
		B:重写run()
		C:创建对象
		D:创建Thread类的对象，并把C步骤的对象作为构造参数传递
```	
```java
MyRunnable.java
public class MyRunnable implements Runnable {
	@Override
	public void run() {
		for (int x = 0; x < 100; x++) {
			System.out.println(Thread.currentThread().getName() + " : " + x);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
MyRunnableDemo.java
public class MyRunnableDemo {
	public static void main(String[] args) {
		MyRunnable my=new MyRunnable();
		Thread t1=new Thread(my,"yifei");
		Thread t2=new Thread(my,"tws");
		// t1.setName("yifei");
		// t2.setName("tws");
		t1.start();
		t2.start();
	}
}

两种方式比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
方式一：继承Thread类
	A：自定义MyThread继承Thread类
	B:在MyThread类中重写run()
	C:创建MyThread类的对象
	D:启动线程对象

问题：
	a:为什么重写run()方法
		run()里面封装的是被线程执行的代码
	b:启动线程对象调用哪个方法？
		start()
	c:run()和start()的区别
		run()直接调用，是调用普通方法的效果
		start()先启动线程，再有JVM调用run()方法

方式二：实现Runnable接口
	A:自定义MyRunnable实现Runnable接口
	B:重写run()
	C:创建对象
	D:创建Thread类的对象，并把C步骤的对象作为构造参数传递

问题：
	有了方式一，为什么还要方式二呢？
		1.可以避免由于Java单继承带来的局限性。
		2.适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码，数据有效分离，较好的体现了面向对象的设计思想。

欢迎与我分享你的看法。
转载请注明出处：http://taowusheng.cn/
微博：寒枫–0-0–
知乎：https://www.zhihu.com/people/tao-wu-sheng
豆瓣：YIFEI