多线程的知识点

线程:每个运行程序都是一个进程,在一个进程中海油多个执行单元同时运行,
这些执行单元可以看做程序执行的一条条线索被称为线程;
并行:就是两个任务同时进行. (需多核CPU)
并发:指两个任务同时请求运行,二处理器只能接受一个任务;
就安排两个任务轮流执行;
JVM 是多线程的:
因为它至少启动了 垃圾回收 和 主线程;
创建线程:
1,自定义一类,继承Thread类
2,重写run()方法;将要做的事情放到方法里;
3,启用 start()方法;

/**
     * 创建线程的两种方式:
     *   
    */
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
        for (int i = 0; i <1060; i++) {
            System.out.println("你!!!!!!!!!!");
}
}
}
class MyThread extends Thread{
    public void run(){
        for (int i = 0; i < 1000; i++) {
            System.out.println("你好我是线程!");
        }
    }

第二种方式创建线程;
1,自定义一个类,实现Runnable接口
2,重写run()方法,将执行的代码放在方法中;
3,创建Runnable接口的子类对象;
4,把Runnable接口的子类对象,当做参数 传递给,Thread 的构造(就是为了使用Thread类中的start()方法来开启线程);
5, 通过 Thread 对象来开启线程;

/**
     * 实现Runnable接口创建线程;
     */
    public static void main(String[] args) {
        MyRunnable my = new MyRunnable();
        Thread th = new Thread(my);
        th.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("ni好!!");
        }
    }
}
class MyRunnable implements Runnable {
        @Override
        public void run(){
            for (int i = 0; i < 1000; i++) {
                System.out.println("你好我是线程!");
            }
        }

匿名内部类实现线程的两种方式:
1,继承Thread,重写Thread中run()方法.

/**
     * 匿名内部类,创建线程;
     */
    public static void main(String[] args) {
        // 1,继承Thread类
        new Thread() {
            public void run() {
                for (int i = 0; i < 2000; i++) {
                    System.out.println("你好,我是继承Thread的匿名内部类!");
                }

            }

        }.start(); // 调用start()方法,开启线程;

        new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 2000; i++) {
                    System.out.println("你好,我是实现Runnable接口的匿名内部类");
                }
            }
        }).start();
    }

给Thread子类线程设置名字:

1,通过构造方法;
new Thread("Thread匿名内部类!") {
            public void run() {
                //this.setName("Thread匿名内部类!");
                for (int i = 0; i < 2000; i++) {
                    System.out.println(this.getName()+"你好,我是继承Thread的匿名内部类!");
                }
            }
        }.start(); // 调用start()方法,开启线程;
2,set方法;
new Thread( ) {
            public void run() {
                 this.setName("Thread匿名内部类!");
                for (int i = 0; i < 2000; i++) {
                    System.out.println(this.getName()+"你好,我是继承Thread的匿名内部类!");
                }
            }

给Runnable 子类线程设置名字:
1,子类实现Runnable接口时候,通过 获取当前的线程对象,设置 和 获取名字;

class MyRunnable implements Runnable {
        @Override
        public void run(){
            Thread.currentThread().setName("lala");//调用Thread类中的currentThread()方法来获取当前线程,在设置名字
            for (int i = 0; i < 1000; i++) {
//通过获得当前线程来获取名字,
                System.out.println(Thread.currentThread().getName()+"你好我是线程!");
            }
        }

2,构造方法:

public Thread(Runnable target,
              String name)
//在Thread 构造方法里,传入Runnable的子类对象 和 名字;

new Thread(new Runnable() {
            public void run() {

                for (int i = 0; i < 2000; i++) {
                    System.out.println(Thread.currentThread().getName()+"你好,我是实现Runnable接口的匿名内部类");
                }
            }
        },"Runnable匿名内部类").start();

休眠线程:
Thread.sleep(毫秒值);
线程休眠指定的毫秒值;

守护线程: (后台线程)
setDaemon(true);设置一个线程为守护线程,该线程不会单独执行;

加入线程:
join();当前线程暂停,等待指定的线程执行结束后,当前线程再继续;
join(毫秒值),给插入的线程指定时间,时间结束后,当前线程继续执行;

礼让线程:
Thread.yield(); 让出CPU,

设置线程的优先级:
setPriority(线程优先级别的范围);设置优先级
线程优先级别的范围
最大是10,默认是5,最小是1;

同步代码块:
使用synchronized(锁对象){ }; 加个锁对象,就是同步代码块;两把锁对象必须是同一个;
锁对象可以是任意的;
锁对象不能用匿名对象,匿名对象不是同一个对象;

非静态的同步方法的锁对象是this;
静态的同步方法的锁对象是该类的字节码对象;

什么时候用到同步代码块?
当多线程并发有多段代码块需要同时执行.希望在执行某一段代码块的时候,CPU不要切换执行权,这个时候就需要用到同步代码块;