介绍
程序(program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程(process) 是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。——生命周期
>如:运行中的QQ，运行中的MP3播放器
>程序是静态的，进程是动态的
>进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
线程(thread)， 进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小；
一个进程中的多个线程共享相同的内存单元/内存地址空间→它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
为什么需要多线程
众所周知，CPU、内存、I/O 设备的速度是有极大差异的，为了合理利用 CPU 的高性能，平衡这三者的速度差异，计算机体系结构、操作系统、编译程序都做出了贡献。
线程状态转换
新建(New)
创建后尚未启动。
就绪(Runnable)
可能正在运行，也可能正在等待 CPU 时间片。
包含了操作系统线程状态中的 Running 和 Ready。
阻塞(Blocking)
等待获取一个排它锁，如果其线程释放了锁就会结束此状态。
无限期等待(Waiting)
等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。
限期等待(Timed Waiting)
无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。
调用 Thread.sleep() 方法使线程进入限期等待状态时，常常用[使一个线程睡眠]进行描述。
调用 Object.wait() 方法使线程进入限期等待或者无限期等待时，常常用[挂起一个线程]进行描述。
睡眠和挂起是用来描述行为，而阻塞和等待用来描述状态。
阻塞和等待的区别在于，阻塞是被动的，它是在等待获取一个排它锁。而等待是主动的，通过调用 Thread.sleep() 和 Object.wait() 等方法进入。
死亡(Terminated)
可以是线程结束任务之后自己结束，或者产生了异常而结束。
线程使用方式
有三种使用线程的方法:
实现 Runnable 接口；
实现 Callable 接口；
继承 Thread 类。
实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。
继承 Thread 类
|
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 26 27 28 29 30 31 32 33 34 35 36 |
public class ThreadTest { /** * 多线程的创建， * 方式一： * 1.继承与Thread类 * 2.重写Thread类的run方法->将此线程执行的操作声明在run中 * 3.创建Thread类的子类 * 4.通过此对象调用start */ public static void main(String[] args) { // 创建Thread类的子类的对象 MyThread t1 = new MyThread(); //不能通过run方法开启线程，因为还会在主线程中运行，应该使用start方法开启线程 //不能通过调用两次start方法来开启两个子线程 t1.start();
//可以通过再创建一个对象来实现
for ( int i= 0 ;i< 1000 ;i++){ if (i% 2 != 0 ){ System.out.println(i+ "****" ); } } }
} class MyThread extends Thread{ @Override public void run() { for ( int i= 0 ;i< 1000 ;i++){ if (i% 2 == 0 ){ System.out.println(i); } } } } |
|
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
/** * 方式二： * 匿名子类创建，针对只调用一次的线程 */ public static void main(String[] args) {
MyThread1 myThread1 = new MyThread1(); myThread1.start(); MyThread2 myThread2 = new MyThread2(); myThread2.start();
//通过匿名子类实现调用：特点只需要调用一次的子线程 new Thread(){ @Override public void run() { for ( int i= 0 ;i< 1000 ;i++){ if (i% 3 == 0 ){ System.out.println(Thread.currentThread().getName()+ "***" +i); } } } }.start(); }
}
class MyThread1 extends Thread{ @Override public void run() { for ( int i= 0 ;i< 100 ;i++){ if (i% 2 != 0 ){ System.out.println(Thread.currentThread().getName()+ "***" +i);
} } } } class MyThread2 extends Thread{ @Override public void run() { for ( int i= 0 ;i< 100 ;i++){ if (i% 2 == 0 ){ System.out.println(Thread.currentThread().getName()+ "***" +i); } } } } |
实现 Runnable 接口
|
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 26 27 28 29 30 31 32 33 34 35 36 37 |
package com.atguigu.juc.runnable;
/** * 创建多线程方式Runnable * 1.创建一个实现Runnable接口的类 * * 2.实现类去实现Runnable中的抽象方法: run( ) * * 3.创建实现类的对象 * * 4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象 * * 5，通过Thread类的对象调用start() */
public class TestThread { public static void main(String[] args) { //3.创建实现类的对象 MyThread myThread = new MyThread(); //4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象 Thread t1 = new Thread(myThread); //5，通过Thread类的对象调用start() t1.start(); } } //1.创建一个实现Runnable接口的类 class MyThread implements Runnable{ //2.实现类去实现Runnable中的抽象方法: run( ) @Override public void run() { for ( int i= 0 ;i< 100 ;i++){ if (i% 2 == 0 ){ System.out.println(i); } } } } |
实现 Callable 接口
线程常见方法
|
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 |
package com.atguigu.juc.tset01;
/** * 1.yield():释放当前cpu的执行权 * * 2.start():启动当前线程;调用当前线程的run() * * 3.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中 * * 4.getName()∶获取当前线程的名字 * * 5.setName():设置当前线程的名字 * * 6.currentThread():静态方法，返回执行当前代码的线程 * * 7.join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。 * * 8.sleep():让当前线程"睡眠]指定的毫秒。在指定的毫秒时间内，当前线程是阻塞状态。 * */ public class MyThreatTest { public static void main(String[] args) {
TestMyThread t1 = new TestMyThread(); t1.start(); new Thread(){ @Override public void run(){ for ( int i= 0 ;i< 100 ;i++){ if (i% 2 == 0 ){ try { sleep( 100 ); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "子线程" + i); yield(); }
} } }.start();
for ( int i= 0 ;i< 100 ;i++){ if (i% 3 == 0 ){ System.out.println(Thread.currentThread().getName() + "main方法" + i); } if (i== 20 ){ try { t1.join(); } catch (InterruptedException e) { e.printStackTrace(); } } } } } class TestMyThread extends Thread{ @Override public void run(){ for ( int i= 0 ;i< 100 ;i++){ if (i% 5 == 0 ){ System.out.println(Thread.currentThread().getName() + "2222222222222子线程" + i);
}
} } } |
synchronized锁机制
一把锁只能同时被一个线程获取，没有获得锁的线程只能等待； 每个实例都对应有自己的一把锁(this),不同实例之间互不影响；例外：锁对象是*.class以及synchronized修饰的是static方法的时候，所有对象公用同一把锁 synchronized修饰的方法，无论方法正常执行完毕还是抛出异常，都会释放锁同步代码---Runnable接口方式
|
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
/** *方式一:同步代码块 * synchronized(同步监视器){ * //需要被同步的代码 * } * 说明: * 1.操作共享数据的代码，即为需要被同步的代码 * 2.共享数据:多个线程共同操作的变量 * 3.同步监视器，俗称:锁。任何一个类的对象都可以作为索 * 4.在Java中，我们通过同步机制，来解决线程的安全问题。 * 补充:在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。 * 方式二:同步方法 * 如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。 * 5.同步的方式，解决了线程的安全问题。---好处 * 操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 */ public class WindowToRunnable { public static void main(String[] args) { Window2 window2 = new Window2();
Thread t1 = new Thread(window2); Thread t2 = new Thread(window2); Thread t3 = new Thread(window2);
t1.setName( "窗口1" ); t2.setName( "窗口2" ); t3.setName( "窗口3" );
t1.start(); t2.start(); t3.start(); } } class Window2 implements Runnable{ //这里不用加static,因为调用的对象只有一个 private int ticket= 100 ; @Override public void run() {
while ( true ) { synchronized ( this .getClass()){ if (ticket > 0 ) { // try { // Thread.sleep(100); // } catch (InterruptedException e) { // e.printStackTrace(); // } System.out.println(Thread.currentThread().getName() + "买票,票号:" + ticket); ticket--; } } } } } |
同步方法--Runnable接口方法
|
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
package com.atguigu.juc.bookPage;
/** * 使用同步方法解决实现Runnable接口的线程安全问题 * 关于同步方法的总结: * 1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。 * 2．非静态的同步方法，同步监视器是: this * 静态的同步方法，同步监视器是:当前类本身 */
public class WindowExtSynn { public static void main(String[] args) { Window4 w1 = new Window4(); Window4 w2 = new Window4(); Window4 w3 = new Window4();
w1.setName( "窗口1" ); w2.setName( "窗口2" ); w3.setName( "窗口3" );
w1.start(); w2.start(); w3.start(); } }
class Window4 extends Thread{ private static int ticket= 100 ;
@Override public void run() { while ( true ){ show();
} }
private static synchronized void show() { if (ticket> 0 ){
System.out.println(Thread.currentThread().getName()+ ":买票：票号为" +ticket); ticket--; } } } |
同步方法---继承方法
|
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
package com.atguigu.juc.bookPage;
/** * 使用同步方法解决实现Runnable接口的线程安全问题 * 关于同步方法的总结: * 1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。 * 2．非静态的同步方法，同步监视器是: this * 静态的同步方法，同步监视器是:当前类本身 */
public class WindowExtSynn { public static void main(String[] args) { Window4 w1 = new Window4(); Window4 w2 = new Window4(); Window4 w3 = new Window4();
w1.setName( "窗口1" ); w2.setName( "窗口2" ); w3.setName( "窗口3" );
w1.start(); w2.start(); w3.start(); } }
class Window4 extends Thread{ private static int ticket= 100 ;
@Override public void run() { while ( true ){ show();
} }
private static synchronized void show() { if (ticket> 0 ){
System.out.println(Thread.currentThread().getName()+ ":买票：票号为" +ticket); ticket--; } } } |
死锁
示例：两个线程都拿到第一层锁的key，然后都需要第二层锁的key，但key在对方手中，而方法没有执行完，都不可能释放key，互相僵持。
|
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
import static java.lang.Thread.sleep;
public class TestSyn { public static void main(String[] args) { StringBuffer s1 = new StringBuffer(); StringBuffer s2 = new StringBuffer(); new Thread(){ @Override public void run() { synchronized (s1) { s1.append( "a" ); s2.append( "1" ); try { sleep( 100 ); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (s2) { s1.append( "b" ); s2.append( "2" ); System.out.println(s1); System.out.println(s2); } }
} }.start();
new Thread( new Runnable() { @Override public void run() { synchronized (s2) { s1.append( "c" ); s2.append( "3" ); try { sleep( 100 ); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (s1) { s1.append( "d" ); s2.append( "4" );
System.out.println(s1); System.out.println(s2); } } } }).start(); } } |
Lock锁机制
|
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
import java.util.concurrent.locks.ReentrantLock;
/** * 解决线程安全问题的方式三: Lock锁--- JDK5.0新增 * * synchronized 与Lock的异同? * 相同:二者都可以解决线程安全问题 * 不同: synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器 * Lock需要手动的启动同步(Lock() )，同时结束同步也需要手动的实现(unlock()) * */ public class LockTest { public static void main(String[] args) { Window6 window6 = new Window6(); Thread t1 = new Thread(window6); Thread t2 = new Thread(window6); Thread t3 = new Thread(window6);
t1.setName( "窗口1" ); t2.setName( "窗口2" ); t3.setName( "窗口3" );
t1.start(); t2.start(); t3.start();
} } class Window6 implements Runnable{ private int ticker= 100 ;
private ReentrantLock lock= new ReentrantLock(); @Override public void run() { while ( true ){ lock.lock(); try { if (ticker> 0 ){ System.out.println(Thread.currentThread().getName()+ "买票：票号：" +ticker);
ticker--; } else { break ; } } finally { lock.unlock(); } } } } |
银行有一个账户。有两个储户分别向同一个账户存3000元，每次存1e00，存3次。每次存完打印账户余额。
|
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
/** * 银行有一个账户。 * 有两个储户分别向同一个账户存3000元，每次存1e00，存3次。每次存完打印账户余额。 * 分析: * 1.是否是多线程问题?是，两个储户线程 * 2.是否有共享数据?有，账户（或账户余额). * 3.是否有线程安全问题?有 * 4.需要考虑如何解决线程安全问题?同步机制:有三种方式。 */ public class AccountTest {
public static void main(String[] args) { Account account = new Account( 0 ); Customer c1 = new Customer(account); Customer c2 = new Customer(account); c1.setName( "A" ); c2.setName( "B" ); c1.start(); c2.start(); } } class Account{ private double balance;
public Account( double balance) { this .balance = balance; } //存钱 public synchronized void deposit( double amt){ //synchronized (this.getClass()) { if (amt> 0 ){ try { Thread.sleep( 100 ); } catch (InterruptedException e) { e.printStackTrace(); } balance+=amt; System.out.println(Thread.currentThread().getName()+ "存钱成功，余额为" +balance); } // } } } class Customer extends Thread{ private Account acc; public Customer(Account acc){ this .acc=acc; }
@Override public void run() { for ( int i= 0 ;i< 30 ;i++){ acc.deposit( 1000 ); } } } |
|
1 2 3 4 5 6 |
A存钱成功，余额为 1000.0 B存钱成功，余额为 2000.0 B存钱成功，余额为 3000.0 B存钱成功，余额为 4000.0 A存钱成功，余额为 5000.0 A存钱成功，余额为 6000.0 |
以上就是学习java多线程的详细内容，更多关于java多线程的资料请关注其它相关文章！
原文链接：https://www.cnblogs.com/coopermini/p/15183138.html