Zaawansowane wyszukiwanie
  Strona Główna » Sklep » Języki programowania » C++ » Moje Konto  |  Zawartość Koszyka  |  Do Kasy   
 Wybierz kategorię
Algorytmy Wzorce UML
Bazy danych
Bezpieczeństwo
Bioinformatyka
Biznes Ekonomia Firma
Chemia
DTP Design
E-biznes
Ekonometria
Elektronika Elektrotechnika
Energetyka
Fizyka
GIS
Grafika użytkowa
Hardware
Informatyczne systemy zarządzania
Informatyka w szkole
Internet
Języki programowania
  Ajax
  Asembler
  ASP ASP.NET
  C
  C#
  C++
  C++ Builder
  CGI Perl
  Chmura obliczeniowa
  CVS
  Delphi
  Eclipse
  Fortran
  Java Hibernate GWT
  JavaScript
  JBuilder
  JSP JavaServlet
  PHP
  Programowanie mobilne
  Programowanie w Windows
  Prolog
  Python Django
  Ruby Rails
  Turbo Pascal
  Visual Studio
Matematyka
Multimedia
Obsługa komputera
Office
Poradniki
Programowanie gier
Programy inżynierskie
Programy matematyczne
Serwery
Sieci Firewalle Protokoły
Słowniki
Systemy operacyjne
Technika
Telekomunikacja
Tworzenie stron WWW

Zobacz pełny katalog »
 Wydawnictwo:
 Difin
Logistyka nowoczesnej gospodarki magazynowej

Logistyka nowoczesnej gospodarki magazynowej

45.00zł
37.80zł
Język C++ i przetwarzanie współbieżne w akcji 89.00zł
Język C++ i przetwarzanie współbieżne w akcji

Tytuł: Język C++ i przetwarzanie współbieżne w akcji
Autor: Anthony Williams
ISBN: 978-83-246-5086-6
Ilość stron: 576
Data wydania: 04/2013
Oprawa: Miękka
Format: 168x237
Wydawnictwo: HELION
Cena: 89.00zł


Odkryj wszystkie tajemnice wielowątkowych aplikacji!

Współbieżne przetwarzanie danych to największe wyzwanie dla programisty. Na każdym kroku czyhają na niego najbardziej wymyślne pułapki, a wykrycie pomyłki stanowi nie lada wyzwanie. Każdy programista wzdryga się na samą myśl o implementacji wielowątkowych rozwiązań. Nie musi tak być!

Dzięki tej książce poradzisz sobie z większością zadań i zwinnie ominiesz zastawione pułapki. W trakcie lektury dowiesz się, jak zidentyfikować zadania, w których zastosowanie współbieżności ma sens, oraz jak zarządzać wątkami. Ponadto nauczysz się chronić współdzielone dane oraz synchronizować współbieżne operacje. Duży nacisk został tu położony na zagadnienia związane z projektowaniem współbieżnych struktur danych oraz kodu. Osobny rozdział poświęcono debugowaniu aplikacji wielowątkowych. Książka ta jest długo oczekiwaną pozycją, która ułatwi codzienne życie programistom C++.

Dzięki tej książce:

  • zaprojektujesz współbieżny kod oraz struktury
  • ochronisz współdzielone dane
  • poznasz zaawansowane metody zarządzania wątkami
  • bez problemu przeprowadzisz debugowanie Twojej wielowątkowej aplikacji

Sprawdź, jak tworzyć niezawodne oprogramowanie wielowątkowe.

Spis treści:

Rozdział 1. Witaj, świecie współbieżności w C++! (19)

  • 1.1. Czym jest współbieżność? (20)
    • 1.1.1. Współbieżność w systemach komputerowych (20)
    • 1.1.2. Modele współbieżności (22)
  • 1.2. Dlaczego warto stosować współbieżność? (25)
    • 1.2.1. Stosowanie współbieżności do podziału zagadnień (25)
    • 1.2.2. Stosowanie współbieżności do podniesienia wydajności (26)
    • 1.2.3. Kiedy nie należy stosować współbieżności (27)
  • 1.3. Współbieżność i wielowątkowość w języku C++ (28)
    • 1.3.1. Historia przetwarzania wielowątkowego w języku C++ (29)
    • 1.3.2. Obsługa współbieżności w nowym standardzie (30)
    • 1.3.3. Efektywność biblioteki wątków języka C++ (30)
    • 1.3.4. Mechanizmy związane z poszczególnymi platformami (32)
  • 1.4. Do dzieła! (32)
    • 1.4.1. "Witaj świecie współbieżności" (32)
  • 1.5. Podsumowanie (34)

Rozdział 2. Zarządzanie wątkami (35)

  • 2.1. Podstawowe zarządzanie wątkami (36)
    • 2.1.1 Uruchamianie wątku (36)
    • 2.1.2. Oczekiwanie na zakończenie wątku (39)
    • 2.1.3. Oczekiwanie w razie wystąpienia wyjątku (39)
    • 2.1.4. Uruchamianie wątków w tle (42)
  • 2.2. Przekazywanie argumentów do funkcji wątku (43)
  • 2.3. Przenoszenie własności wątku (46)
  • 2.4. Wybór liczby wątków w czasie wykonywania (49)
  • 2.5. Identyfikowanie wątków (52)
  • 2.6. Podsumowanie (54)

Rozdział 3. Współdzielenie danych przez wątki (55)

  • 3.1. Problemy związane ze współdzieleniem danych przez wątki (56)
    • 3.1.1. Sytuacja wyścigu (58)
    • 3.1.2. Unikanie problematycznych sytuacji wyścigu (59)
  • 3.2. Ochrona współdzielonych danych za pomocą muteksów (60)
    • 3.2.1. Stosowanie muteksów w języku C++ (60)
    • 3.2.2. Projektowanie struktury kodu z myślą o ochronie współdzielonych danych (62)
    • 3.2.3. Wykrywanie sytuacji wyścigu związanych z interfejsami (63)
    • 3.2.4. Zakleszczenie: problem i rozwiązanie (71)
    • 3.2.5. Dodatkowe wskazówki dotyczące unikania zakleszczeń (73)
    • 3.2.6. Elastyczne blokowanie muteksów za pomocą szablonu std::unique_lock (79)
    • 3.2.7. Przenoszenie własności muteksu pomiędzy zasięgami (80)
    • 3.2.8. Dobór właściwej szczegółowości blokad (82)
  • 3.3. Alternatywne mechanizmy ochrony współdzielonych danych (84)
    • 3.3.1. Ochrona współdzielonych danych podczas inicjalizacji (84)
    • 3.3.2. Ochrona rzadko aktualizowanych struktur danych (88)
    • 3.3.3. Blokowanie rekurencyjne (90)
  • 3.4. Podsumowanie (91)

Rozdział 4. Synchronizacja współbieżnych operacji (93)

  • 4.1. Oczekiwanie na zdarzenie lub inny warunek (94)
    • 4.1.1. Oczekiwanie na spełnienie warunku za pomocą zmiennych warunkowych (95)
    • 4.1.2. Budowa kolejki gwarantującej bezpieczne przetwarzanie wielowątkowe przy użyciu zmiennych warunkowych (97)
  • 4.2. Oczekiwanie na jednorazowe zdarzenia za pomocą przyszłości (102)
    • 4.2.1. Zwracanie wartości przez zadania wykonywane w tle (103)
    • 4.2.2. Wiązanie zadania z przyszłością (106)
    • 4.2.3. Obietnice (szablon std::promise) (109)
    • 4.2.4. Zapisywanie wyjątku na potrzeby przyszłości (111)
    • 4.2.5. Oczekiwanie na wiele wątków (112)
  • 4.3. Oczekiwanie z limitem czasowym (115)
    • 4.3.1. Zegary (115)
    • 4.3.2. Okresy (117)
    • 4.3.3. Punkty w czasie (118)
    • 4.3.4. Funkcje otrzymujące limity czasowe (120)
  • 4.4. Upraszczanie kodu za pomocą technik synchronizowania operacji (121)
    • 4.4.1. Programowanie funkcyjne przy użyciu przyszłości (122)
    • 4.4.2. Synchronizacja operacji za pomocą przesyłania komunikatów (127)
  • 4.5. Podsumowanie (131)

Rozdział 5. Model pamięci języka C++ i operacje na typach atomowych (133)

  • 5.1. Podstawowe elementy modelu pamięci (134)
    • 5.1.1. Obiekty i miejsca w pamięci (134)
    • 5.1.2. Obiekty, miejsca w pamięci i przetwarzanie współbieżne (135)
    • 5.1.3. Kolejność modyfikacji (136)
  • 5.2. Operacje i typy atomowe języka C++ (137)
    • 5.2.1. Standardowe typy atomowe (138)
    • 5.2.2. Operacje na typie std::atomic_flag (141)
    • 5.2.3. Operacje na typie std::atomic (143)
    • 5.2.4. Operacje na typie std::atomic - arytmetyka wskaźników (146)
    • 5.2.5. Operacje na standardowych atomowych typach całkowitoliczbowych (147)
    • 5.2.6. Główny szablon klasy std::atomic<> (147)
    • 5.2.7. Wolne funkcje dla operacji atomowych (150)
  • 5.3. Synchronizacja operacji i wymuszanie ich porządku (151)
    • 5.3.1. Relacja synchronizacji (152)
    • 5.3.2. Relacja poprzedzania (154)
    • 5.3.3. Porządkowanie pamięci na potrzeby operacji atomowych (155)
    • 5.3.4. Sekwencje zwalniania i relacja synchronizacji (175)
    • 5.3.5. Ogrodzenia (178)
    • 5.3.6. Porządkowanie operacji nieatomowych za pomocą operacji atomowych (180)
  • 5.4. Podsumowanie (182)

Rozdział 6. Projektowanie współbieżnych struktur danych przy użyciu blokad (183)

  • 6.1. Co oznacza projektowanie struktur danych pod kątem współbieżności? (184)
    • 6.1.1. Wskazówki dotyczące projektowania współbieżnych struktur danych (185)
  • 6.2. Projektowanie współbieżnych struktur danych przy użyciu blokad (186)
    • 6.2.1. Stos gwarantujący bezpieczeństwo przetwarzania wielowątkowego przy użyciu blokad (187)
    • 6.2.2. Kolejka gwarantująca bezpieczeństwo przetwarzania wielowątkowego przy użyciu blokad i zmiennych warunkowych (190)
    • 6.2.3. Kolejka gwarantująca bezpieczeństwo przetwarzania wielowątkowego przy użyciu szczegółowych blokad i zmiennych warunkowych (194)
  • 6.3. Projektowanie złożonych struktur danych przy użyciu blokad (207)
    • 6.3.1. Implementacja tablicy wyszukiwania gwarantującej bezpieczeństwo przetwarzania wielowątkowego przy użyciu blokad (207)
    • 6.3.2. Implementacja listy gwarantującej bezpieczeństwo przetwarzania wielowątkowego przy użyciu blokad (213)
  • 6.4. Podsumowanie (218)

Rozdział 7. Projektowanie współbieżnych struktur danych bez blokad (219)

  • 7.1. Definicje i ich praktyczne znaczenie (220)
    • 7.1.1. Rodzaje nieblokujących struktur danych (220)
    • 7.1.2. Struktury danych bez blokad (221)
    • 7.1.3. Struktury danych bez oczekiwania (222)
    • 7.1.4. Zalety i wady struktur danych bez blokad (222)
  • 7.2. Przykłady struktur danych bez blokad (223)
    • 7.2.1. Implementacja stosu gwarantującego bezpieczeństwo przetwarzania wielowątkowego bez blokad (224)
    • 7.2.2. Eliminowanie niebezpiecznych wycieków - zarządzanie pamięcią w strukturach danych bez blokad (228)
    • 7.2.3. Wykrywanie węzłów, których nie można odzyskać, za pomocą wskaźników ryzyka (233)
    • 7.2.4. Wykrywanie używanych węzłów metodą zliczania referencji (242)
    • 7.2.5. Zmiana modelu pamięci używanego przez operacje na stosie bez blokad (247)
    • 7.2.6. Implementacja kolejki gwarantującej bezpieczeństwo przetwarzania wielowątkowego bez blokad (252)
  • 7.3. Wskazówki dotyczące pisania struktur danych bez blokad (264)
    • 7.3.1. Wskazówka: na etapie tworzenia prototypu należy stosować tryb std::memory_order_seq_cst (265)
    • 7.3.2. Wskazówka: należy używać schematu odzyskiwania pamięci bez blokad (265)
    • 7.3.3 Wskazówka: należy unikać problemu ABA (266)
    • 7.3.4. Wskazówka: należy identyfikować pętle aktywnego oczekiwania i wykorzystywać czas bezczynności na wspieranie innego wątku (267)
  • 7.4. Podsumowanie (267)

Rozdział 8. Projektowanie współbieżnego kodu (269)

  • 8.1. Techniki dzielenia pracy pomiędzy wątki (270)
    • 8.1.1. Dzielenie danych pomiędzy wątki przed rozpoczęciem przetwarzania (271)
    • 8.1.2. Rekurencyjne dzielenie danych (272)
    • 8.1.3. Dzielenie pracy według typu zadania (276)
  • 8.2. Czynniki wpływające na wydajność współbieżnego kodu (279)
    • 8.2.1. Liczba procesorów (280)
    • 8.2.2. Współzawodnictwo o dane i ping-pong bufora (281)
    • 8.2.3. Fałszywe współdzielenie (284)
    • 8.2.4. Jak blisko należy rozmieścić dane? (285)
    • 8.2.5. Nadsubskrypcja i zbyt intensywne przełączanie zadań (285)
  • 8.3. Projektowanie struktur danych pod kątem wydajności przetwarzania wielowątkowego (286)
    • 8.3.1. Podział elementów tablicy na potrzeby złożonych operacji (287)
    • 8.3.2. Wzorce dostępu do danych w pozostałych strukturach (289)
  • 8.4. Dodatkowe aspekty projektowania współbieżnych struktur danych (291)
    • 8.4.1. Bezpieczeństwo wyjątków w algorytmach równoległych (291)
    • 8.4.2. Skalowalność i prawo Amdahla (298)
    • 8.4.3. Ukrywanie opóźnień za pomocą wielu wątków (300)
    • 8.4.4. Skracanie czasu reakcji za pomocą technik przetwarzania równoległego (301)
  • 8.5. Projektowanie współbieżnego kodu w praktyce (303)
    • 8.5.1. Równoległa implementacja funkcji std::for_each (304)
    • 8.5.2. Równoległa implementacja funkcji std::find (306)
    • 8.5.3. Równoległa implementacja funkcji std::partial_sum (312)
  • 8.6. Podsumowanie (322)

Rozdział 9. Zaawansowane zarządzanie wątkami (323)

  • 9.1. Pule wątków (324)
    • 9.1.1. Najprostsza możliwa pula wątków (324)
    • 9.1.2. Oczekiwanie na zadania wysyłane do puli wątków (327)
    • 9.1.3. Zadania oczekujące na inne zadania (330)
    • 9.1.4. Unikanie współzawodnictwa w dostępie do kolejki zadań (333)
    • 9.1.5. Wykradanie zadań (335)
  • 9.2. Przerywanie wykonywania wątków (340)
    • 9.2.1. Uruchamianie i przerywanie innego wątku (340)
    • 9.2.2. Wykrywanie przerwania wątku (342)
    • 9.2.3. Przerywanie oczekiwania na zmienną warunkową (343)
    • 9.2.4. Przerywanie oczekiwania na zmienną typu std::condition_variable_any (346)
    • 9.2.5. Przerywanie pozostałych wywołań blokujących (348)
    • 9.2.6. Obsługa przerwań (349)
    • 9.2.7. Przerywanie zadań wykonywanych w tle podczas zamykania aplikacji (350)
  • 9.3. Podsumowanie (352)

Rozdział 10. Testowanie i debugowanie aplikacji wielowątkowych (353)

  • 10.1. Rodzaje błędów związanych z przetwarzaniem współbieżnym (354)
    • 10.1.1. Niechciane blokowanie (354)
    • 10.1.2. Sytuacje wyścigu (355)
  • 10.2. Techniki lokalizacji błędów związanych z przetwarzaniem współbieżnym (357)
    • 10.2.1. Przeglądanie kodu w celu znalezienia ewentualnych błędów (357)
    • 10.2.2. Znajdowanie błędów związanych z przetwarzaniem współbieżnym poprzez testowanie kodu (359)
    • 10.2.3. Projektowanie kodu pod kątem łatwości testowania (361)
    • 10.2.4. Techniki testowania wielowątkowego kodu (363)
    • 10.2.5. Projektowanie struktury wielowątkowego kodu testowego (366)
    • 10.2.6. Testowanie wydajności wielowątkowego kodu (369)
  • 10.3. Podsumowanie (370)

Dodatek A Krótki przegląd wybranych elementów języka C++11 (371)

  • A.1. Referencje do r-wartości (371)
    • A.1.1. Semantyka przenoszenia danych (372)
    • A.1.2. Referencje do r-wartości i szablony funkcji (375)
  • A.2. Usunięte funkcje (376)
  • A.3. Funkcje domyślne (377)
  • A.4. Funkcje constexpr (381)
    • A.4.1. Wyrażenia constexpr i typy definiowane przez użytkownika (382)
    • A.4.2. Obiekty constexpr (385)
    • A.4.3. Wymagania dotyczące funkcji constexpr (385)
    • A.4.4. Słowo constexpr i szablony (386)
  • A.5. Funkcje lambda (386)
    • A.5.1. Funkcje lambda odwołujące się do zmiennych lokalnych (388)
  • A.6. Szablony zmiennoargumentowe (391)
    • A.6.1. Rozwijanie paczki parametrów (392)
  • A.7. Automatyczne określanie typu zmiennej (395)
  • A.8. Zmienne lokalne wątków (396)
  • A.9. Podsumowanie (397)

Dodatek B Krótkie zestawienie bibliotek przetwarzania współbieżnego (399)
Dodatek C Framework przekazywania komunikatów i kompletny przykład implementacji systemu bankomatu (401)
Dodatek D Biblioteka wątków języka C++ (419)

  • D.1. Nagłówek (419)
    • D.1.1. Szablon klasy std::chrono::duration (420)
    • D.1.2. Szablon klasy std::chrono::time_point (429)
    • D.1.3. Klasa std::chrono::system_clock (431)
    • D.1.4. Klasa std::chrono::steady_clock (433)
    • D.1.5. Definicja typu std::chrono::high_resolution_clock (435)
  • D.2. Nagłówek (435)
    • D.2.1. Klasa std::condition_variable (436)
    • D.2.2. Klasa std::condition_variable_any (444)
  • D.3. Nagłówek (452)
    • D.3.1. Definicje typów std::atomic_xxx (454)
    • D.3.2. Makra ATOMIC_xxx_LOCK_FREE (454)
    • D.3.3. Makro ATOMIC_VAR_INIT (455)
    • D.3.4. Typ wyliczeniowy std::memory_order (455)
    • D.3.5. Funkcja std::atomic_thread_fence (456)
    • D.3.6. Funkcja std::atomic_signal_fence (457)
    • D.3.7. Klasa std::atomic_flag (457)
    • D.3.8. Szablon klasy std::atomic (460)
    • D.3.9. Specjalizacje szablonu std::atomic (471)
    • D.3.10. Specjalizacje szablonu std::atomic (472)
  • D.4. Nagłówek (489)
    • D.4.1. Szablon klasy std::future (490)
    • D.4.2. Szablon klasy std::shared_future (495)
    • D.4.3. Szablon klasy std::packaged_task (501)
    • D.4.4. Szablon klasy std::promise (507)
    • D.4.5. Szablon funkcji std::async (513)
  • D.5. Nagłówek (514)
    • D.5.1. Klasa std::mutex (515)
    • D.5.2. Klasa std::recursive_mutex (518)
    • D.5.3. Klasa std::timed_mutex (520)
    • D.5.4. Klasa std::recursive_timed_mutex (524)
    • D.5.5. Szablon klasy std::lock_guard (529)
    • D.5.6. Szablon klasy std::unique_lock (530)
    • D.5.7. Szablon funkcji std::lock (540)
    • D.5.8. Szablon funkcji std::try_lock (541)
    • D.5.9. Klasa std::once_flag (541)
    • D.5.10. Szablon funkcji std::call_once (542)
  • D.6. Nagłówek (543)
    • D.6.1. Szablon klasy std::ratio (544)
    • D.6.2. Alias szablonu std::ratio_add (544)
    • D.6.3. Alias szablonu std::ratio_subtract (545)
    • D.6.4. Alias szablonu std::ratio_multiply (545)
    • D.6.5. Alias szablonu std::ratio_divide (546)
    • D.6.6. Szablon klasy std::ratio_equal (547)
    • D.6.7. Szablon klasy std::ratio_not_equal (547)
    • D.6.8. Szablon klasy std::ratio_less (547)
    • D.6.9. Szablon klasy std::ratio_greater (548)
    • D.6.10. Szablon klasy std::ratio_less_equal (548)
    • D.6.11. Szablon klasy std::ratio_greater_equal (548)
  • D.7. Nagłówek (549)
    • D.7.1. Klasa std::thread (549)
    • D.7.2. Przestrzeń nazw std::this_thread (558)

Materiały dodatkowe (561)

Język C++ i przetwarzanie współbieżne w akcji
--- Pozycja niedostępna.---
Klienci, którzy kupili „Język C++ i przetwarzanie współbieżne w akcji”, kupili także:
<b>LINQ to Objects w C# 4.0</b>, <font color="navy">Troy Magennis</font>, <font color="green"> Wydawnictwo HELION</font>
LINQ to Objects w C# 4.0, Troy Magennis, Wydawnictwo HELION
<b>Programowanie równoległe i asynchroniczne w C# 5.0</b>, <font color="navy">Warczak, Jacek Matulewski, Rafał Pawłaszek, Piotr Sybilski, Dawid Bory</font>, <font color="green"> Wydawnictwo HELION</font>
Programowanie równoległe i asynchroniczne w C# 5.0, Warczak, Jacek Matulewski, Rafał Pawłaszek, Piotr Sybilski, Dawid Bory, Wydawnictwo HELION
<b>Tworzenie gier internetowych Receptury</b>, <font color="navy">Evan Burchard</font>, <font color="green"> Wydawnictwo HELION</font>
Tworzenie gier internetowych Receptury, Evan Burchard, Wydawnictwo HELION
<b>Tworzenie nowoczesnych aplikacji graficznych w WPF</b>, <font color="navy">Cisek Jarosław</font>, <font color="green"> Wydawnictwo HELION</font>
Tworzenie nowoczesnych aplikacji graficznych w WPF, Cisek Jarosław, Wydawnictwo HELION
<b>API nowoczesnej strony WWW. Usługi sieciowe w PHP</b>, <font color="navy">Lorna Jane Mitchell</font>, <font color="green"> Wydawnictwo HELION</font>
API nowoczesnej strony WWW. Usługi sieciowe w PHP, Lorna Jane Mitchell, Wydawnictwo HELION
<b>Język C++ Kompendium wiedzy Wydanie IV</b>, <font color="navy">Bjarne Stroustrup</font>, <font color="green"> Wydawnictwo HELION</font>
Język C++ Kompendium wiedzy Wydanie IV, Bjarne Stroustrup, Wydawnictwo HELION
 Koszyk
0 przedmiotów
Producent
Tu można zobaczyć wszystkie książki z wydawnictwa:

Wydawnictwo HELION
 Kategoria:
 Energetyka
Fotowoltaika w teorii i praktyce

Fotowoltaika w teorii i praktyce

82.00zł
65.60zł
Informacje
Regulamin sklepu.
Koszty wysyłki.
Polityka prywatności.
Jak kupować?
Napisz do Nas.
 Wydawnictwa
 Poradniki
Chemia organiczna Część III Clayden J., Greeves N.,. Warren S., Wothers S WNT
Transact-SQL Czarna księga Marcin Szeliga HELION
Rootkity Sabotowanie jądra systemu Windows Greg Hoglund, Jamie Butler HELION
C++ Algorytmy i struktury danych Adam Drozdek HELION
Bezpieczeństwo sieci w Linuksie. Wykrywanie ataków i obrona przed nimi za pomocą iptables, psad i fwsnort Michael Rash HELION
Układy mikroprocesorowe przykłady rozwiązań Bartłomiej Zieliński HELION
Podstawy fizyki Tom 5 Wydanie 2 David Halliday, Robert Resnick, Jearl Walker Naukowe PWN
Chemia organiczna Część II Clayden J., Dreeves N., Warren S., Wothers P. WNT
Kwalifikacje E.14 i EE.09. Podstawy programowania w języku JavaScript. Ćwiczenia praktyczne do nauki zawodu technik info Piotr Siewniak HELION

niedziela, 27 maj 2018   Mapa strony |  Nowości |  Dzisiejsze promocje |  Koszty wysyłki |  Kontakt z nami