1.7线程实现方式

Thread类

创建线程方式一

• 定义一个Thread的子类
• 重写run方法
• 创建Thread的子类对象
• 调用start方法，开启新线程，执行run方法

//自定义线程类
 public class MyThread extends Thread{ 
      public MyThread(String name){      
                 super(name);         
       }     
        /* * 重写run方法      
          *  定义线程要执行的代码      
          *  */     
        public void run(){            
            for (int i = 0; i < 20; i++) {
                 System.out.println(getName()+i);             
               }          
          }     
  }  
//测试类
public class Demo {     
      public static void main(String[] args) {        
           System.out.println("这里是main线程");         
           MyThread mt = new MyThread("小强");                   
           mt.start();//开启了一个新的线程           
           for (int i = 0; i < 20; i++) {      
                  System.out.println("旺财:"+i);              
             }          
         }      
  }   

构造方法

• public Thread():分配一个新的线程对象。
• public Thread(String name) :分配一个指定名字的新的线程对象。
• public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
• public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。

常用方法

• public String getName() :获取当前线程名称。
• public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
• public void setName(String name):改变线程名称，使之与参数name相同；（也可以使用构造方法设置线程名称）
• public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。

创建线程的第二种方式

• 采用java.lang.Runnable 也是非常常见的一种，我们只需要重写run方法即可。
• 步骤如下：

1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
3. 调用线程对象的start()方法来启动线程。

public class MyRunnable implements Runnable
{ 
    @Override      
    public void run() {      
        for (int i = 0; i < 20; i++) {          
             System.out.println(Thread.currentThread().getName()+" "+i);              
         }          
      }   
 }
 
public class Demo {     
    public static void main(String[] args) {         
           //创建自定义类对象  线程任务对象         
           MyRunnable mr = new MyRunnable();         
           //创建线程对象         
           Thread t = new Thread(mr, "小强");         
           t.start();         
           for (int i = 0; i < 20; i++) {             
                System.out.println("旺财 " + i);         
            }     
       } 
}

Thread 和 Runnable的区别

• 避免了单继承的局限性
  一个类只能继承一个类，类继承了Thread类就不能继承其他的类
  而实现了Runnable接口，还可以继承其他的类，实现其他的接口
• 增强了程序的扩展性，降低了程序的耦合性(解耦)
  实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）

匿名内部类方式实现多线程创建

public class ThreadTest {
    public static void main(String[] args) {
        //第一种匿名方式：线程的父类是Thread
        new Thread(){
            @Override
            public void run() { 
                System.out.println("hello world");
            }
        }.start();

        //第二种匿名方式：实现Runnable接口
        Runnable r=new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        };
        new Thread(r).start();

        //第三种方式：简化接口
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        }).start();
    }
}

多线程

并发和并行

• 并发：指两个或多个事件在同一时段内发生
• 并行：两个或多个事件在同一时刻发生（同时发生）
  

进程和线程

• 进程：一个内存中运行的运用程序，每一个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；
• 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程；
  

线程调度

• 分时调度
  所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
• 抢占式调度
  优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，java使用的为抢占式调度