edycja wątków

PC20-ObiektyIWatki/src/main/java/watki/kolekcje/OpakowywanieSync.java

@@ -51,7 +51,7 @@ public class OpakowywanieSync {
                 synchronizowana.remove(0);
             }
             
-            for (String element : synchronizowana) {
+            for(String element : synchronizowana) {
                 // ...
                 // mamy pewność, że w czasie przeglądania inne wątki nie będą ruszać tej listy
             }

PC20-ObiektyIWatki/src/main/java/watki/kolekcje/ProdKons1.java

@@ -2,7 +2,6 @@ package watki.kolekcje;
 
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
 
 // Kolejki blokujące mają dodatkowo metody take i put, które działają w sposób blokujący.

PC20-ObiektyIWatki/src/main/java/watki/konta/v1_brak_synchronizacji/Przeploty.java

@@ -10,7 +10,6 @@ class Przeploty {
         
         Osoba ala = new Osoba("Ala", "Kowalska", LocalDate.now());
         Konto konto = new Konto(1, 1000_000, ala);		
-        
         System.out.println(konto);
         
         Thread wplacacz = new Thread(() -> {

PC20-ObiektyIWatki/src/main/java/watki/konta/v3_synchronizacja_blokow/WyplacanieBezOczekiwania.java

@@ -3,7 +3,6 @@ package watki.konta.v3_synchronizacja_blokow;
 import java.io.IOException;
 
 class WyplacanieBezOczekiwania {
-
     static volatile boolean koniec = false;
 
     public static void main(String[] args) {

PC20-ObiektyIWatki/src/main/java/watki/konta/v3_synchronizacja_blokow/WyplacanieBezOczekiwaniaAtomicBoolean.java

+package watki.konta.v3_synchronizacja_blokow;
+
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+class WyplacanieBezOczekiwaniaAtomicBoolean {
+    static final AtomicBoolean dzialamy = new AtomicBoolean(true);
+
+    public static void main(String[] args) {
+         final Osoba ala = new Osoba("Ala", "Kowalska", "2001-01-01");
+         final Konto konto = new Konto(1, 1700, ala);   	 
+         
+        System.out.println("początek " + konto);
+
+        Thread wplacacz = new Thread(new Runnable() {
+            public void run() {
+                while(dzialamy.get()) {
+                    konto.wplata(1000);
+                 
+                    System.out.println("wpłacacz: wpłaciłem 1000, saldo = " + konto.getSaldo());
+                    try {
+                        Thread.sleep(4000);
+                    } catch (InterruptedException e) {
+                    }
+                }
+            }
+        });
+        Thread wyplacacz = new Thread(new Runnable() {
+            public void run() {
+                while (dzialamy.get()) {
+                    try {
+                        konto.wyplata(100);
+                    } catch (BrakSrodkow e) {
+                        System.err.println("BRAK ŚRODKÓW");
+                    }
+                    System.out.println("wypłacacz: wypłaciłem 100, saldo = " + konto.getSaldo());
+                    try {
+                        Thread.sleep(200);
+                    } catch (InterruptedException e) {
+                    }
+                }
+            }
+        });
+
+        wplacacz.start();
+        wyplacacz.start();
+
+        System.out.println("Wątki wystartowały");
+        System.out.println("Naciśnij enter aby zakończyć");
+        try {
+            System.in.read();
+        } catch (IOException e1) {
+        }
+    
+        dzialamy.set(false);
+        wplacacz.interrupt();
+        wyplacacz.interrupt();
+
+        try {
+            wplacacz.join();
+            wyplacacz.join();
+        } catch (InterruptedException e) {
+            System.err.println("INTERRUPTED");
+        }
+
+        System.out.println("na końcu: " + konto);
+    }
+}

PC20-ObiektyIWatki/src/main/java/watki/util/AtomowyLicznik.java

 package watki.util;
 
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 
 public class AtomowyLicznik {
     private static AtomicInteger licznik;
     private static final int N = 10_000_000;
     
+    private final static AtomicBoolean systemDostepny = new AtomicBoolean(false);
+    
     private static class Watek implements Runnable {
         public void run() {
             for(int i=0; i<N; i++) {
@@ -20,7 +23,7 @@ public class AtomowyLicznik {
 //				licznik.getAndAdd(3); // try{return x} finally {x+=3}
 //				licznik.get();
 //				licznik.set(5);
-//				licznik.compareAndSet(50, 1000); // tylko jeśli aktualna wartość to 50, to ustaw ową wartość 1000
+//				licznik.compareAndSet(50, 1000); // tylko jeśli aktualna wartość to 50, to ustaw nową wartość 1000
                 
                 // Aby użycie takiego obiektu było poprawne, należy wykonywać operacje "jednym wywołaniem"
                 // np. poprawne jest
@@ -49,6 +52,8 @@ public class AtomowyLicznik {
         th1.start();
         th2.start();
         
+        systemDostepny.set(true);
+        
         System.out.println("Uruchomiłem");
         
         try {

PC20-ObiektyIWatki/src/main/java/watki/util/Wymiana.java

@@ -5,7 +5,6 @@ import java.util.concurrent.Exchanger;
 public class Wymiana {
 
     public static void main(String[] args) {
-
         final Exchanger<String> schowek = new Exchanger<>();
         
         Thread th1 = new Thread(new Runnable() {