线程、进程、并行、并发概念多线程三种实现方式
1、继承Thread2、Runnable3、Callable接口 多线程的五种状态常用方法线程安全问题
解决办法（同步存储）
1）同步代码块2）同步方法3）Lock（jdk1.5加入） 线程池练习题
线程、进程、并行、并发概念并发：并发是指在同一时间段内有多个事情发生，但是每一时刻只能处理一个事情。
并行：并行是指在同一时间段内有多个事情，同一时刻可以处理多个事情。
进程：进程是指在内存中运行的应用程序，每个进程都有自己独立的空间内存。
线程：线程是进程中的一个执行单元，一个进程中至少有一个线程。
1）创建一个Thread的子类MyThread，重写run()方法。
2）new一个MyThread对象myThread，
3）通过myThread.start()启动线程
代码：
class MyThread extends Thread {
@Override
public void run() {
//线程执行体
System.out.println("线程体执行");
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
}
}
2、Runnable
1）自定义一个Runnable的实现类MyThread，重写run()方法，
2）new一个MyThread对象myThread。
3）new一个Thread对象thread将myThread传入构造器。
4）通过thread.start启动线程。
代码：
class MyThread implements Runnable {
@Override
public void run() {
//线程执行体
System.out.println("线程执行体执行");
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyThread MyThread = new MyThread();
Thread thread = new Thread(MyThread);
thread.start();
}
}
3、Callable接口
一般情况下，使用Runnable接口和Thread实现的线程我们都无返回结果，但是如果有些场合需要线程返回结果，就要使用Callable、Future。Callable只能在ExecutorService的线程池中跑。
示例：
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(10);
MyCallable myCallable1 = new MyCallable();
MyCallable myCallable2 = new MyCallable();
Future submit = executorService.submit(myCallable1);
Future submit1 = executorService.submit(myCallable2);
System.out.println(submit.get());
}
}
class MyCallable implements Callable{
@Override
public Integer call() throws Exception {
int sum = 0;
Integer nextInt = new Random().nextInt();
for (int i = 0; i < nextInt; i++) {
sum += i;
}
return sum;
}
}
多线程的五种状态
1、新建状态：就是new的过程。
2、就绪状态：线程对象创建后，其他线程调用该对象的start()方法后，该线程就进入到就绪状态。
3、运行状态：就绪状态的线程获取到了cup，进入运行状态，执行程序代码。
4、阻塞状态：当一个线程在运行过程中因为某些原因，让出了cpu执行权，此时该线程处于阻塞状态。
5、死亡状态：线程执行完毕正常退出或遇到错误异常退出。
Thread.sleep(long millis) 线程睡眠
让当前线程进入阻塞状态，millis是设置睡眠毫秒值，到达设定时间后会转为就绪状态，sleep不释放锁。
wait() 线程等待
释放锁，让当前线程进入等待状态，待其他线程调用此线程对象的notify方法或notifyAll()方法时回到就绪状态。
notify() notifyAll() 线程唤醒
唤醒之前wait()的线程。
join() 合并线程
在当前线程中调用另一个线程，当前线程进入阻塞状态，直至被调用线程执行完再有阻塞状态转为就绪状态。
yield() 线程让步
放弃当前拥有的cup资源，让当前运行线程切换到可运行状态，以允许拥有相同优先级的线程之间能轮转执行。线程安全问题
当两个或两个以上的线程需要对同一数进行读写操作时，会出现线程安全问题。
解决办法（同步存储） 1）同步代码块语法：
synchronized(临界资源对象){ //对临界资源对象加锁
//代码（原⼦操作）此代码块中的代码，在同一时间只能有一个线程执行。
}
class TicketThread implements Runnable {
private Integer ticket = 100; //有一百张票
@Override
public void run() {
synchronized (this.getClass()) {
while(ticket > 0) {
System.out.println(Thread.currentThread().getName()+"卖出第" + ticket-- + "张票");
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
TicketThread ticketThread = new TicketThread();
new Thread(ticketThread,"窗口1").start();
new Thread(ticketThread,"窗口2").start();
new Thread(ticketThread,"窗口3").start();
}
}
2）同步方法
同步方法就是用synchronized 修饰的方法，
它会有一个隐含锁对象
普通方法的隐含锁对象是this
如果是静态同步方法，隐含锁对象是类名.class，如果此代码块执行，就没有其他线程能调用此类中其他的同步静态方法
class TicketThread implements Runnable {
private static Integer ticket = 100; //有一百张票
@Override
public void run() {
ticket();
}
public static synchronized void ticket(){
while(ticket > 0) {
System.out.println(Thread.currentThread().getName()+"卖出第" + ticket-- + "张票");
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
TicketThread ticketThread = new TicketThread();
new Thread(ticketThread,"窗口1").start();
new Thread(ticketThread,"窗口2").start();
new Thread(ticketThread,"窗口3").start();
}
}
3）Lock（jdk1.5加入）
| 方法名 | 描述 |
|---|---|
| void lock() | 获取锁，如锁被占用，则等待 |
| boolean tryLock() | 尝试获取锁（成功返回true，失败返回false） |
| void unlock() | 释放锁 |
| void await() | 将该线程放到条件的等待集中 |
| void signalAll() | 解除该条件的等待集中的所有线程的阻塞状态 |
| void signal() | 从该条件的等待集中随机的选择一个线程，解除其阻塞状态 |
注意：unlock()要写在finally里面，
class MyArrayList {
private Lock lock = new ReentrantLock();
private String[] str = {"a","b","","",""};
private Integer count = 2;
public void add(String s) {
lock.lock();
try{
str[count] = s;
try {
Thread.sleep(200); //模拟线程安全问题
} catch (InterruptedException e) {
e.printStackTrace();
}
count++;
}finally {
lock.unlock();
}
}
public String[] getAll() {
return str;
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyArrayList thread = new MyArrayList();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
thread.add("he");
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
thread.add("hell");
}
});
t1.start();
t2.start();
try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
String[] all = thread.getAll();
for (String s : all) {
System.out.println(s);
}
}
}
线程池
java.util.concurrent.Executor是线程池的顶级接口，但是严格意义上将，Executor并不是一个线程池，而是一个执行线程的工具，真正的线程池接口是java.util.concurrent.ExecutorService。
| 方法 | 描述 |
|---|---|
| newFixedThreadPool | 创建一个固定长度的线程池 |
| newCachedThreadPoll | 创建一个可缓存的线程池，当需求增加时线程数量也会增加。 |
| newSingleThreadPool | 创建一个单线程的线程池 |
| newScheduledThreadPool | 创建一个固定长度的线程池，而且以延迟或定时方式来执行 |
- 创建两个线程，让它们依次打印ABABAB共打印十次。
class MyThread implements Runnable{
private String name;
private Integer count = 10;
public MyThread(String name) {
this.name = name;
}
@Override
public void run() {
while(count-- > 0) {
synchronized (MyThread.class){
System.out.println(Thread.currentThread().getName() + name);
MyThread.class.notifyAll();
try {
MyThread.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
new Thread(new MyThread("A")).start();
new Thread(new MyThread("B")).start();
}
}
- 启动三个线程打印递增的数字，线程1先打印1,2,3,4,5，然后线程2打印6,7,8,9,10，线程3打印11,12,13,14,15一直打印到75；
方式一：
class MyThread implements Runnable{
private static Integer count = 1;
private Integer cid; //线程标记位
private Integer sid; //当前应当运行的线程
public MyThread(Integer cid) {
this.cid = cid;
}
@Override
public void run() {
while(count <=75) {
synchronized (MyThread.class) {
sid = (count/5)%3+1;
if(sid == cid) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() +"--"+ count++);
}
MyThread.class.notifyAll();
}else{
try {
MyThread.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
new Thread(new MyThread(1)).start();
new Thread(new MyThread(2)).start();
new Thread(new MyThread(3)).start();
}
}
方式二：
class MyThread implements Runnable{
public MyThread(Object prev, Object self) {
this.prev = prev;
this.self = self;
}
private Object prev;
private Object self;
private static Integer count = 1;
@Override
public void run() {
synchronized (prev){
synchronized (self){
while(count <= 75) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + count++);
}
self.notify();
}
if(count >= 75) {
try {
prev.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) throws InterruptedException {
Object A = new Object();
Object B = new Object();
Object C = new Object();
new Thread(new MyThread(C,A),"线程一").start();
//Thread.sleep(20);
new Thread(new MyThread(A,B),"线程二").start();
//Thread.sleep(20);
new Thread(new MyThread(B,C),"线程三").start();
//Thread.sleep(20);
}
}
- 创建两个线程，其中一个输出1-52，另外一个输出A-Z。输出格式要求：12A 34B 56C 78D
class PrintNum implements Runnable{
public PrintNum(Object obj) {
this.obj = obj;
}
private Object obj;
private Integer count = 1;
@Override
public void run() {
synchronized (obj) {
while(count <= 52) {
if(count>1 && count%2==1) {
System.out.print(" ");
}
System.out.print(count++);
if(count%2==1) {
obj.notify();
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
class PrintChar implements Runnable{
public PrintChar(Object obj) {
this.obj = obj;
}
private Object obj;
@Override
public void run() {
synchronized (obj) {
for (char i = 'A'; i <= 'Z'; i++) {
System.out.print(i);
obj.notify();
if(i < 'Z') {
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
Object obj = new Object();
new Thread(new PrintNum(obj)).start();
new Thread(new PrintChar(obj)).start();
}
}
