线程是程序的执行单元，执行路径。是程序使用cpu的最基本单位
多线程 -- 程序有多条执行路径，提高应用进程的使用率
进程中线程越多，抢到cpu执行权概率越高。线程的执行有随机性
java程序的运行原理：
由java命令启动jvm，jvm启动就相当于启动了一个进程，接着由该程序创建了一个主线程去调用main方法
jvm的启动是多线程的，因为垃圾回收线程也要启动，否则容易出现内存溢出。（gc线程和主线程）
java多线程程序：
方法1：继承thread类，并重写run()方法，创建对象，执行对象。
run()方法: thread类中的run()用来包含那些被线程执行的代码(封装被线程执行的代码)（不单独调用run方法(直接调用是普通方法)，调用start()）
start()方法：首先启动了线程，然后再由jvm去调用该线程的run()方法
方法2：实现runnable接口
a:自定义类实现runnable
b:重写run()方法
c:创建myrunnable类的对象
d:创建thread类的对象，把c步骤的对象作为构造参数传递
解决了java单继承的局限性，适合多个相同程序代码去处理同一个资源的情况，把线程相同的代码，数据有效分离
一些内建方法：
public final string getname() //获取线程名称
public final string setname(): //设置线程名称
public static thread currentthread(): //返回当前正在执行的线程对象
抢占式调度模型（java）：优先让优先级高的线程使用cpu
public final int getpriority(): //返回线程对象的优先级 public final void setpriority(): //设置线程优先级
优先级范围1-10，默认为5，最低为1，最高为5
线程控制：
public static void sleep(long millis) //线程休眠
public final void join(): //线程加入 （等待线程终止)
public static void yield(): //线程礼让 暂停当前正在执行的线程对象，并执行其他线程
//让多个线程的执行更加和谐，但不能保证
public final void setdaemon(boolean on)： //设置守护线程 //当正在运行的线程都是守护线程时，jvm退出，该方法必须在启动线程前调用
public void interrupt(): //中断线程，把线程的状态终止，并抛出一个interruptexception
线程的生命周期：（图解）
线程同步：synchronized关键字
将多条语句操作的共享数据代码包成一个整体，让某个线程在执行的时候别人不执行
前提：多个线程； 注意：多个线程使用同一个锁对象
优点：解决了多线程的安全问题
缺点：当线程相当时，因为每个线程都会去判断同步上的锁，很耗费资源，无形中降低了程序的运行效率，容易产生死锁
使用同步代码块或者同步方法
死锁：
死锁代码举例：
我要评论1 public class mylock {
2 // 创建两把锁对象
3 public static final object obja = new object();
4 public static final object objb = new object();
5 }
1 public class deadlock extends thread {
2
3 private boolean flag;
4
5 public deadlock(boolean flag) {
6 this.flag = flag;
7 }
8
9 @override
10 public void run() {
11 if (flag) {
12 synchronized (mylock.obja) {
13 system.out.println("if obja");
14 synchronized (mylock.objb) {
15 system.out.println("if objb");
16 }
17 }
18 } else {
19 synchronized (mylock.objb) {
20 system.out.println("else objb");
21 synchronized (mylock.obja) {
22 system.out.println("else obja");
23 }
24 }
25 }
26 }
27 }
1 public class dielockdemo {
2 public static void main(string[] args) {
3 deadlock dl1 = new deadlock(true);
4 deadlock dl2 = new deadlock(false);
5
6 dl1.start();
7 dl2.start();
8 }
9 }
等待唤醒机制：
object类提供三个方法：
wait() :等待
notify():唤醒单个线程
notifyall():唤醒所有线程
为什么不在thread类中： 因为这些方法必须通过锁对象调用，而锁对象可以是任意锁对象，所以定义在object类中
semaphore信号量：
信号量(semaphore)，又被称为信号灯，在多线程环境下用于协调各个线程, 以保证它们能够正确、合理的使用公共资源。信号量维护了一个许可集，我们在初始化semaphore时需要为这个许可集传入一个数量值，该数量值代表同一时间能访问共享资源的线程数量。
线程可以通过acquire()方法获取到一个许可，然后对共享资源进行操作，注意如果许可集已分配完了，那么线程将进入等待状态，直到其他线程释放许可才有机会再获取许可，线程释放一个许可通过release()方法完成，"许可"将被归还给semaphore。
多线程案例：
电影院卖票：电影院一共有100张票，有三个窗口卖票，模拟电影院售票：
使用同步代码块：
public class sellticket implements runnable {
// 定义100张票
private int tickets = 100;
//创建锁对象
private object obj = new object();
@override
public void run() {
while (true) {
synchronized (obj) {
if (tickets > 0) {
try {
thread.sleep(100);
} catch (interruptedexception e) {
e.printstacktrace();
}
system.out.println(thread.currentthread().getname()
+ "正在出售第" + (tickets--) + "张票");
}
}
}
}
}
public class sellticketdemo {
public static void main(string[] args) {
// 创建资源对象
sellticket st = new sellticket();
// 创建三个线程对象
thread t1 = new thread(st, "窗口1");
thread t2 = new thread(st, "窗口2");
thread t3 = new thread(st, "窗口3");
// 启动线程
t1.start();
t2.start();
t3.start();
}
}
使用同步方法:
1 package lab2;
2
3 public class sellticket implements runnable {
4
5 // 定义100张票
6 private static int tickets = 100;
7
8 @override
9 public void run() {
10 while (true) {
11 sellticket();
12 }
13 }
14
15 private synchronized void sellticket() {
16 if (tickets > 0) {
17 try {
18 thread.sleep(100);
19 } catch (interruptedexception e) {
20 e.printstacktrace();
21 }
22 system.out.println(thread.currentthread().getname()
23 + "正在出售第" + (tickets--) + "张票 ");
24 }
25 }
26 }
使用锁方法：
1 import java.util.concurrent.locks.lock;
2 import java.util.concurrent.locks.reentrantlock;
3
4 public class sellticket implements runnable {
5
6 // 定义票
7 private int tickets = 100;
8
9 // 定义锁对象
10 private lock lock = new reentrantlock();
11
12 @override
13 public void run() {
14 while (true) {
15 try {
16 // 加锁
17 lock.lock();
18 if (tickets > 0) {
19 try {
20 thread.sleep(100);
21 } catch (interruptedexception e) {
22 e.printstacktrace();
23 }
24 system.out.println(thread.currentthread().getname()
25 + "正在出售第" + (tickets--) + "张票");
26 }
27 } finally {
28 // 释放锁
29 lock.unlock();
30 }
31 }
32 }
33
34 }
ornamental garden problem：(使用bakery class) 花园有两个旋转门，可进可出，监控花园内的人数
volatile关键字: specifying a variable as volatile instructs the compiler to load and store the value of the variable at each use. 另外更多说明可以参考：https://www.cnblogs.com/daxin/p/3364014.html
bakery algorithm面包店算法
bakery.java
1 package lab2;
2
3 public class bakery {
4 public int nthreads;
5
6 private volatile int[] ticket;
7 private volatile boolean[] choosing;
8
9 bakery(int nth) {
10 nthreads = nth;
11 ticket = new int[nthreads];
12 choosing = new boolean[nthreads];
13
14 for (int i = 0; i < nthreads; i++) {
15 system.out.println(i + ticket[1]);
16 ticket[i] = 0;
17 choosing[i] = false;
18 }
19 }
20
21 private int getnextnumber() {
22 int largest = 0;
23 for (int i = 0; i < nthreads; i++) {
24 if (ticket[i] > largest)
25 largest = ticket[i];
26 }
27 return largest + 1;
28 }
29
30 private boolean isfavouredthread(int i, int j) {
31 if ((ticket[i] == 0) || (ticket[i] > ticket[j]))
32 return false;
33 else {
34 if (ticket[i] < ticket[j])
35 return true;
36 else
37 return (i < j);
38 }
39 }
40
41 void wanttoentercs(int threadid) {
42 choosing[threadid] = true;
43 ticket[threadid] = getnextnumber();
44 choosing[threadid] = false;
45
46 for (int otherthread = 0; otherthread < nthreads; otherthread++) {
47 while(choosing[otherthread]) {
48 // busy-wait
49 }
50 // break any ties between threads
51 while (isfavouredthread(otherthread,threadid)) {
52 // busy-wait
53 }
54 }
55 }
56
57 void exitcs(int threadid) {
58 // leave critical section
59 ticket[threadid] = 0;
60 }
61 }
couter.java
1 package lab2;
2
3 public class counter {
4 volatile int value = 0;
5
6 counter() {
7 system.out.println("total: " + value);
8 }
9
10 boolean increment() {
11 int temp = value; //read[v]
12 simulate.hwinterrupt();
13 value = temp + 1; //write[v+1]
14 system.out.println("total: " + value);
15 return true;
16 }
17
18 boolean decrement() {
19 int temp = value; //read[v]
20 simulate.hwinterrupt();
21 if (temp == 0) return false;
22 simulate.hwinterrupt();
23 value = temp - 1; //write[v+1]
24 system.out.println("total: " + value);
25 return true;
26 }
27 }
28
29 class simulate {
30 public static void hwinterrupt() {
31 if (math.random() < 0.5)
32 try{
33 thread.sleep(200);
34 } catch(interruptedexception ie) {};
35 }
36 }
turnstile.java
1 package lab2;
2
3 /* notes:
4 * no modifications need be made to the bakery class. instead, the turnstile
5 * class and counter classes are adjusted to allow for "exit" turnstiles as well
6 * as entrance turnstiles. this solution incorporates a system to prevent the
7 * number of people in the gardens from being negative, so the sleep call in
8 * this class can be commented out. study the code in the counter and turnstile
9 * classes to see how how this works.
10 * */
11
12 public class gardens {
13 static turnstile west;
14 static turnstile east;
15 static turnstile westexit;
16 static turnstile eastexit;
17 static counter people;
18 static bakery bakery;
19
20 public static void main(string[] args) {
21 people = new counter();
22 bakery = new bakery(4);
23
24 west = new turnstile(0, true, people, bakery);
25 east = new turnstile(1, true, people, bakery);
26
27 westexit = new turnstile(2, false, people, bakery);
28 eastexit = new turnstile(3, false, people, bakery);
29
30 west.start();
31 east.start();
32
33 /*
34 try {
35 thread.sleep(5000);
36 } catch (interruptedexception e) {
37 }
38 */
39
40 westexit.start();
41 eastexit.start();
42 }
43 }
garden.java
1 package lab2;
2
3 public class gardens {
4 static turnstile west;
5 static turnstile east;
6 static turnstile westexit;
7 static turnstile eastexit;
8 static counter people;
9 static bakery bakery;
10
11 public static void main(string[] args) {
12 people = new counter();
13 bakery = new bakery(4);
14
15 west = new turnstile(0, true, people, bakery);
16 east = new turnstile(1, true, people, bakery);
17
18 westexit = new turnstile(2, false, people, bakery);
19 eastexit = new turnstile(3, false, people, bakery);
20
21 west.start();
22 east.start();
23
24 /*
25 try {
26 thread.sleep(5000);
27 } catch (interruptedexception e) {
28 }
29 */
30
31 westexit.start();
32 eastexit.start();
33 }
34 }
生产者消费者，操作列表：
buffer.java
1 import java.util.linkedlist;
2 import java.util.nosuchelementexception;
3
4 class buffer {
5 linkedlist<integer> queue = new linkedlist<integer>();
6
7 public synchronized void write(int i) {
8 queue.add(i);
9 }
10
11 public synchronized int read() {
12 try {
13 return queue.removefirst();
14 } catch(nosuchelementexception e) {
15 // the buffer is empty!?
16 return -1;
17 }
18 }
19 }
producer.java
1 class producer implements runnable {
2 buffer buffer;
3
4 public producer(buffer b) {
5 buffer = b;
6 }
7
8 public void run() {
9 for(int i = 0; i < 20; i++) {
10 buffer.write(i);
11 system.out.println("thread " + thread.currentthread().getid() +
12 " writes " + i);
13 }
14 }
15 }
consumer.java
1 class consumer implements runnable {
2 buffer buffer;
3
4 public consumer(buffer b) {
5 buffer = b;
6 }
7
8 public void run() {
9 for(int i = 0; i < 10; i++) {
10 try {
11 thread.sleep(10);
12 } catch (interruptedexception e) {
13 }
14 int x = buffer.read();
15 system.err.println("thread " + thread.currentthread().getid() +
16 " reads " + x);
17 }
18 }
19 }
infbuffer.java
1 public class infbuffer {
2 public static void main(string args[]) {
3 buffer b = new buffer();
4 consumer c1 = new consumer(b);
5 consumer c2 = new consumer(b);
6 producer p = new producer(b);
7 (new thread(c1)).start();
8 (new thread(c2)).start();
9 (new thread(p)).start();
10 }
11 }
生产者消费者，修改学生姓名和年龄并获取:（只能一打一大片，无法实现生产者生产后等待消费者消费后再产生）
1 public class student {
2 string name;
3 int age;
4 }
1 public class setthread implements runnable {
2
3 private student s;
4 private int x = 0;
5
6 public setthread(student s) {
7 this.s = s;
8 }
9
10 @override
11 public void run() {
12 while (true) {
13 synchronized (s) {
14 if (x % 2 == 0) {
15 s.name = "student1";
16 s.age = 27;
17 } else {
18 s.name = "student2";
19 s.age = 30;
20 }
21 x++;
22 }
23 }
24 }
25 }
1 public class getthread implements runnable {
2 private student s;
3
4 public getthread(student s) {
5 this.s = s;
6 }
7
8 @override
9 public void run() {
10 while (true) {
11 synchronized (s) {
12 system.out.println(s.name + "---" + s.age);
13 }
14 }
15 }
16 }
1 public class studentdemo {
2 public static void main(string[] args) {
3 //创建资源
4 student s = new student();
5
6 //设置和获取的类
7 setthread st = new setthread(s);
8 getthread gt = new getthread(s);
9
10 //线程类
11 thread t1 = new thread(st);
12 thread t2 = new thread(gt);
13
14 //启动线程
15 t1.start();
16 t2.start();
17 }
18 }
生产者消费者，修改学生姓名和年龄并获取:（使用等待唤醒机制改进）
1 public class student {
2 string name;
3 int age;
4 boolean flag; //添加一个标记，默认为false，表示生产者是否生成值
5 }
1 public class setthread implements runnable {
2
3 private student s;
4 private int x = 0;
5
6 public setthread(student s) {
7 this.s = s;
8 }
9
10 @override
11 public void run() {
12 while (true) {
13 synchronized (s) {
14 //判断有没有
15 if(s.flag) {
16 try {
17 s.wait();
18 } catch (interruptedexception e) {
19 e.printstacktrace();
20 }
21 }
22
23 if (x % 2 == 0) {
24 s.name = "student1";
25 s.age = 27;
26 } else {
27 s.name = "student2";
28 s.age = 30;
29 }
30 x++;
31
32 //修改标记
33 s.flag = true;
34 //唤醒线程
35 s.notify();
36 }
37 }
38 }
49 }
1 public class getthread implements runnable {
2 private student s;
3
4 public getthread(student s) {
5 this.s = s;
6 }
7
8 @override
9 public void run() {
10 while (true) {
11 synchronized (s) {
12 if (!s.flag) {
13 try {
14 s.wait();
15 } catch (interruptedexception e) {
16 e.printstacktrace();
17 }
18 }
19 system.out.println(s.name + "---" + s.age);
20
21 //修改标记
22 s.flag = false;
23 //唤醒线程
24 s.notify();
25
26 }
27 }
28 }
29 }
public class studentdemo { //同上
public static void main(string[] args) {
//创建资源
student s = new student();
//设置和获取的类
setthread st = new setthread(s);
getthread gt = new getthread(s);
//线程类
thread t1 = new thread(st);
thread t2 = new thread(gt);
//启动线程
t1.start();
t2.start();
}
}
厕所排队（使用信号量）
1 import java.util.random;
2 import java.util.concurrent.semaphore;
3
4 class wc extends thread {
5 private string name;
6 private semaphore wc;
7
8 public wc(string name, semaphore wc) {
9 this.name = name;
10 this.wc = wc;
11 }
12
13 @override
14 public void run() {
15 int availablepermit = wc.availablepermits();
16 if (availablepermit > 0) {
17 system.out.println(name+",好开心啊，我终于有坑了");
18 }else {
19 system.out.println(name+"怎么没有坑了。。。");
20 }
21
22 try {
23 wc.acquire();
24 system.out.println(name+",好开心啊，我终于抢到了！");
25 thread.sleep(new random().nextint(1000));
26 system.out.println(name+",好爽啊，终于上完了！");
27 wc.release();
28 } catch (interruptedexception e) {
29
30 }
31 }
32 }
33
34 public class demo {
35 public static void main(string[] args) {
36 semaphore semaphore = new semaphore(3);
37
38 for (int i = 0; i < 10; i++) {
39 wc wc = new wc("第"+i+"个人", semaphore);
40 wc.start();
41 }
42 }
43 }
the sleeping barber (生产者消费者，信号量)
1 import java.util.concurrent.semaphore;
2
3 public class barber implements runnable{
4
5 semaphore customerwaiting, seats, barbersleeping;
6
7 barber(semaphore customerwaiting, semaphore seats, semaphore barbersleeping) {
8 this.customerwaiting = customerwaiting;
9 this.seats = seats;
10 this.barbersleeping = barbersleeping;
11 }
12
13 public void run() {
14
15 while (true){
16
17 // get a customer, sleep otherwise
18 try {
19 customerwaiting.acquire();
20 } catch (interruptedexception e) {}
21
22 // cut the hair of the customer
23 system.out.println("cutting hair");
24 barbersleeping.release();
25
26 }
27 }
28 }
1 import java.util.concurrent.semaphore;
2
3 public class customer implements runnable{
4
5 semaphore customerwaiting, seats, barbersleeping;
6
7 boolean cut = false;
8 customer(semaphore customerwaiting, semaphore seats, semaphore barbersleeping) {
9 this.customerwaiting = customerwaiting;
10 this.seats = seats;
11 this.barbersleeping = barbersleeping;
12
13 }
14
15 public void run() {
16 while (!cut) {
17
18 // a random delay
19 // don't want all the threads trying at once!
20 try {
21 thread.sleep((long)(math.random()*100));
22 } catch (interruptedexception e1) {}
23
24 // try to get a seat in the waiting room
25 try {
26 seats.acquire();
27 } catch (interruptedexception e) {}
28 system.out.println(seats.availablepermits());
29
30 system.out.println(thread.currentthread().getname()+" is sitting down");
31 // try and wake barber
32 customerwaiting.release();
33
34
35 // get hair cut
36 try {
37 barbersleeping.acquire();
38 } catch (interruptedexception e) {}
39 cut = true;
40 seats.release();
41
42 }
43 system.out.println(thread.currentthread().getname()+" has had hair cut");
44 }
45 }
1 import java.util.concurrent.semaphore;
2
3 public class runner {
4
5 public static void main(string[] args) {
6
7 semaphore barbersleeping = new semaphore(1);
8 semaphore customerwaiting = new semaphore(1);
9 try {
10 customerwaiting.acquire();
11 barbersleeping.acquire();
12 } catch (interruptedexception e) {
13 }
14
15 semaphore seats = new semaphore(3);
16
17 barber bar = new barber(customerwaiting,seats,barbersleeping);
18 thread bthread = new thread(bar);
19 bthread.start();
20
21 int ncust = 30;
22 customer customers[] = new customer[ncust];
23 thread cthread[] = new thread[ncust];
24
25 for (int i=0;i<ncust;i++) {
26 customers[i] = new customer(customerwaiting,seats,barbersleeping);
27 cthread[i] = new thread(customers[i]);
28 cthread[i].start();
29 }
30 }
31 }
如对本文有疑问， 点击进行留言回复！！
MyBatis中selectByExample和selectByExampleWithBLOBs区别
【Spring Data JPA自学笔记三】Spring Data JPA的基础和高级查询方法
踩坑mybatis-plus,### Cause: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Table ‘mybatis_
Postgresql结合postgis使用java的JDBC连接
网友评论