测试类
public class Demo01 {
 　　public static void main(String[] args) { 
　　//创建自定义线程对象 
　　MyThread mt = new MyThread("新的线程！"); 
　　//开启新线程 
　　mt.start(); //在主方法中执行for循环
　　for (int i = 0; i < 10; i++) { 
　　　　System.out.println("main线程！"+i);
 　　　　} 
　　}
}

自定义线程类：
public class MyThread extends Thread { 
　　//定义指定线程名称的构造方法 
　　public MyThread(String name) {
 　//调用父类的String参数的构造方法，指定线程的名称
 　super(name); 

1.12 创建线程方式二

步骤如下：

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);
} } }

• 通过实现Runnable接口，使得该类有了多线程类的特征。
• run()方法是多线程程序的一个执行目标。
• 所有的多线程代码都在run方法里面。
• Thread类实际上也是实现了Runnable接口的类。

1.13  Thread和Runnable的区别

　　如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

1.14  实现Runnable接口比继承Thread类所具有的优势：

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

public class NoNameInnerClassThread {
public static void main(String[] args) {
// new Runnable(){
// public void run(){
// for (int i = 0; i < 20; i++) {
// System.out.println("张宇:"+i);
// }
// }
// };     //‐‐‐这个整体 相当于new MyRunnable()
Runnable r = new Runnable(){
public void run(){
for (int i = 0; i < 20; i++) {
System.out.println("张宇:"+i);
} }
};
new Thread(r).start();
for (int i = 0; i < 20; i++) {
System.out.println("费玉清:"+i);
} } }

2.1  线程安全

•  同步代码块。

  • synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
    • 格式：synchronized(同步锁){需要同步操作的代码}

    • /*
      * 执行卖票操作
      */
      @Override
      public void run() {
      //每个窗口卖票的操作
      //窗口 永远开启
      while(true){
      synchronized (lock) {
      if(ticket>0){//有票 可以卖
      //出票操作
      //使用sleep模拟一下出票时间
      try {
      Thread.sleep(50);
      } catch (InterruptedException e) {
      // TODO Auto‐generated catch block
      e.printStackTrace();
      }
      //获取当前线程对象的名字
      String name = Thread.currentThread().getName();
      System.out.println(name+"正在卖:"+ticket‐‐);
      } } }
      

       

•  同步方法。

  • 同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
    • 格式： public synchronized void method(){可能会产生线程安全问题的代码}

    • /*
      * 执行卖票操作
      */
      @Override
      public void run() {
      //每个窗口卖票的操作
      //窗口 永远开启
      while(true){
      sellTicket();
      } }
      /*
      * 锁对象 是 谁调用这个方法 就是谁
      * 隐含 锁对象 就是 this
      *
      */
      public synchronized void sellTicket(){
      if(ticket>0){//有票 可以卖
      //出票操作
      //使用sleep模拟一下出票时间
      try {
      Thread.sleep(100);
      } catch (InterruptedException e) {
      // TODO Auto‐generated catch block
      e.printStackTrace();
      }
      //获取当前线程对象的名字
      String name = Thread.currentThread().getName();
      System.out.println(name+"正在卖:"+ticket‐‐);
      } } }
      

       

•  锁机制。

  • java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。Lock锁也称同步锁，加锁与释放锁方法化了。
    • public void lock() :加同步锁。
    • public void unlock() :释放同步锁　

    • Lock lock = new ReentrantLock();
      /*
      * 执行卖票操作
      */
      @Override
      public void run() {
      //每个窗口卖票的操作
      //窗口 永远开启
      while(true){
      lock.lock();
      if(ticket>0){//有票 可以卖
      //出票操作
      //使用sleep模拟一下出票时间
      try {
      Thread.sleep(50);
      } catch (InterruptedException e) {
      // TODO Auto‐generated catch block
      e.printStackTrace();
      }
      //获取当前线程对象的名字
      String name = Thread.currentThread().getName();
      System.out.println(name+"正在卖:"+ticket‐‐);
      }
      lock.unlock();
      } } }
      

      　　

2.3  线程状态