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()中断线程,把线程状态终止,并抛出一个异常,然后执行完后续代码

线程的生命周期

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

多线程生命周期图解

多线程实现方式二

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