1、线程的状态

package com.cjg.xiancheng;public class threadStop implements Runnable   {    //如果不填 boolean的默认值为flase    private  boolean flag=true;    @Override    public void run() {        int i =1;       while (flag){           System.out.println("****"+i++);       }    }    public void stop(){        this.flag=false;    }    public static void main(String[] args) {        threadStop threadStop = new threadStop();        new Thread(threadStop,"me").start();        for (int i = 0; i < 1000; i++) {            System.out.println("main"+i);            if (i==500){                threadStop.stop();                System.out.println("stop=============================================================================");            }        }    }}

package com.cjg.xiancheng;import java.text.SimpleDateFormat;import java.util.Date;public class threadTime {    public static void main(String[] args) throws InterruptedException {        f();        while (true){            //打印当前系统的时间            Date date = new Date(System.currentTimeMillis());            Thread.sleep(1000);            System.out.println(new SimpleDateFormat("yyyy--MM--dd HH:mm:ss").format(date));        }    }    public static void f() throws InterruptedException {        int i=10;        while (true){            Thread.sleep(100);            System.out.println(i--);            if (i==0)break;        }    }}

2、线程的礼让

package com.cjg.xiancheng;public class threadYield {    public static void main(String[] args) {        didi didi = new didi();        new Thread(didi,"一号弟弟").start(); new Thread(didi,"二号弟弟").start();    }}class didi implements Runnable{    @Override    public void run() {        System.out.println(Thread.currentThread().getName()+"start");        Thread.yield();        System.out.println(Thread.currentThread().getName()+"end");    }}

Join

◆Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞。

package com.cjg.xiancheng;public class threadJoin implements  Runnable {    @Override    public void run() {        for (int i = 0; i < 1000; i++) {            System.out.println(Thread.currentThread().getName()+i);        }    }    public static void main(String[] args) throws InterruptedException {        threadJoin threadJoin = new threadJoin();        Thread thread = new Thread(threadJoin, "vip");                thread.start(); //线程已经开始        for (int i = 0; i < 500; i++) {            System.out.println(Thread.currentThread().getName()+i);            if (i==100){                //知道join线程结束都只执行join线程                thread.join();            }        }    }}

package com.cjg.xiancheng;public class threadStatus {    public static void main(String[] args) throws InterruptedException {        Thread thread =new Thread(()->{            for (int i = 0; i <5 ; i++) {                try {                    Thread.sleep(1000);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }            System.out.println("============================================================================");        });        Thread.State state = thread.getState();        System.out.println(state);        thread.start();        while (state !=Thread.State.TERMINATED){            Thread.sleep(100);          state = thread.getState();            System.out.println(state);        }    }}

4、线程的优先级

优先级低只是意味着获得调度的概率低。并不是优先级低就不会被调用了。这都是看CPU的调度。

可能会造成性能倒置

package com.cjg.xiancheng;public class threadMore {    public static void main(String[] args) {        System.out.println(Thread.currentThread().getName()+"的"+Thread.currentThread().getPriority());        more more = new more();        Thread thread = new Thread(more);  Thread thread1 = new Thread(more);  Thread thread2 = new Thread(more);        thread.setPriority(Thread.MAX_PRIORITY);        thread1.setPriority(4);        thread2.setPriority(Thread.MIN_PRIORITY);        thread.start(); thread1.start(); thread2.start();    }}class more implements Runnable{    @Override    public void run() {        System.out.println(Thread.currentThread().getName()+"的"+Thread.currentThread().getPriority());    }}

◆线程分为用户线程和守护线程

◆虚拟机必须确保用户线程执行完毕

◆虚拟机不用等待守护线程执行完毕

◆如：后台记录操作日志、监控内存、垃圾回收等待……

package com.cjg.xiancheng;public class threadDaemon {    public static void main(String[] args) {        me me = new me();        parents parents = new parents();        //设置守护线程        Thread thread = new Thread(me);        thread.setDaemon(true);        thread.start();        new Thread(parents).start();    }}class me implements Runnable{    @Override    public void run() {        while (true){            System.out.println("我守护着你");        }    }}class parents implements Runnable{    @Override    public void run() {        for (int i = 0; i <= 36500; i++) {            System.out.println("爸妈开心的活了"+i);        }        System.out.println("happy end");    }}

队列加锁，保证线程安全，对应sql数据库的回滚。

◆由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：

◆一个线程持有锁会导致其他所有需要此锁的线程挂起；

◆在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引 起性能问题；

◆如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。

==每个线程在自己的工作内存交互，内存控制不当会造成数据不一致==

package com.cjg.xiancheng;public class syn {    public static void main(String[] args) {        buy buy = new buy();        new Thread(buy,"11111").start();  new Thread(buy,"2222222222").start();  new Thread(buy,"33333333333").start();    }}class  buy implements  Runnable{    private boolean flag=true;    private int tiket = 10;    @Override    public void run() {        while (flag){            try {                buyTikets();            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }    private synchronized void buyTikets() throws InterruptedException {        if (tiket<=0){            flag=false;            return;        }        System.out.println(Thread.currentThread().getName()+"获得第"+tiket--+"票");        Thread.sleep(100);    }}//之前加锁的是 this  如果加锁不为 this 用程序块代替  . 注意索的是谁 ,需要增删改的对象synchronized (对象 obj){}